Introducing Dev AI: Deployments in Plain English

Temps ships AI-powered deployment agents that autonomously deploy, debug, and fix your applications — not just suggest actions, but execute them inside your own infrastructure. Unlike GitHub Copilot Autofix or generic AI chat tools, Temps agents run on a cron schedule, read live logs and error traces, open pull requests, and roll back bad deploys — all without leaving your self-hosted environment.

What Does "AI-Powered Deployment" Actually Mean?

Most tools that call themselves "AI-powered" give you a chatbot or autocomplete. Temps AI agents are different: they are autonomous background workers defined in YAML, stored at .temps/agents/*.yaml in your repository, and executed by the AgentCronScheduler inside the Temps binary (verified in crates/temps-agents/src/services/cron_scheduler.rs).

When a cron fires, the scheduler emits an AutopilotTrigger job onto the internal JobQueue. The executor picks it up, spins up the configured AI CLI — claude_cli, codex_cli, or opencode (all three are real providers verified in crates/temps-agents/src/ai_cli/) — streams output line by line, and persists the run in the agent_runs table. The agent can read your deployment logs, query error-tracking data, push code to a branch, and open a pull request — all autonomously.

AI-Powered Temps vs Manual CI/CD vs GitHub Copilot Autofix

Three Verified Temps AI Agent Claims

1. Agents are defined in repository YAML with a proven schema

Your agent configuration lives in .temps/agents/ at the root of your repo. The AgentYamlConfig struct (in crates/temps-core/src/repo_config.rs) defines the exact fields:

name: error-fixer
description: Detects and fixes new error groups automatically
on:
  schedule:
    cron: "0 */6 * * *"
  error:
    new_issue: true
system: |
  You are an automated error fixer. Analyze the error, find the root cause,
  write a fix, and open a pull request. Use {{error_type}} and {{error_message}}
  as context variables.
ai_provider: claude_cli
max_turns: 20
branch_prefix: fix/agent-
deliverable: pull_request

The system: field (not system_prompt:) is the system prompt. max_turns controls how many AI turns run before the agent stops (verified: crates/temps-agents/src/ai_cli/claude.rs passes --max-turns to the CLI when max_turns > 0).

2. AgentCronScheduler is a real service, not marketing copy

The AgentCronScheduler struct (line 17 of crates/temps-agents/src/services/cron_scheduler.rs) polls AgentConfigService for scheduled agents and emits AutopilotTrigger jobs when a cron expression fires. It uses minute-aligned polling, the same pattern as the database cron config service. Runs are recorded in the agent_runs table; agent configs come from the project_agents table. Both are Sea-ORM entities, not in-memory state.

3. Three AI CLI providers are fully implemented

Temps supports three AI CLI backends in production code:

• claude_cli — wraps Claude Code CLI, passes --max-turns, streams JSON output line-by-line (crates/temps-agents/src/ai_cli/claude.rs)
• codex_cli — wraps OpenAI Codex CLI, same streaming interface (crates/temps-agents/src/ai_cli/codex.rs)
• opencode — wraps the OpenCode CLI, configured via opencode auth add (crates/temps-agents/src/ai_cli/opencode.rs)

No specific model is hardcoded in source — the ai_model field lets you pick the model within the chosen provider, or leave it null to let the CLI use its default.

Why AI-Powered Deployments Without Self-Hosting Fall Short

When your AI agent runs inside a third-party SaaS, it can only see what the platform exposes through its API. Temps agents run inside your own server, with direct access to:

• The Pingora-based reverse proxy (Cloudflare-built, open-source) for real request logs
• Built-in error tracking (replaces Sentry) — no external API key required
• Built-in session replay (replaces FullStory) — full user context for bug reproduction
• Health check results — every 5 seconds, 2 consecutive successes required, 60-second error window before auto-rollback triggers
• Deployment history — the agent can compare the current deploy against the last known-good one

This is the core architectural difference: the AI agent is not a layer on top of your infrastructure. It is a first-class component inside the same binary that runs your proxy, analytics, and error tracker.

What the Autofixer Does (Interactive Mode)

Beyond scheduled autonomous agents, Temps ships an interactive Autofixer for error groups surfaced in the dashboard. The flow is two-phase:

1. Analyze — the agent reads the error, its stack trace, affected sessions, and recent deployments
2. Review — you see the AI's analysis and proposed fix before any code changes land

You can approve, reject, or ask follow-up questions. When approved, the agent opens a branch and pull request. The Autofixer uses the same agent_runs infrastructure as autonomous agents, with SSE streaming so you see the AI output in real time.

Getting Started

Temps is Apache 2.0. Self-hosting is free — you only pay for the server you already run it on. Temps Cloud, a coming-soon managed add-on for telemetry retention, offsite backups, and AI credits, is not yet priced.

# Install Temps (single binary — replaces Vercel, Sentry, PostHog, FullStory, Pingdom, and managed DBs)
curl -fsSL https://temps.sh/install.sh | bash

# Deploy your first app
bunx @temps-sdk/cli deploy my-app -b main -e production -y

# Enable AI agents — add a YAML file to your repo and redeploy
mkdir -p .temps/agents
cat > .temps/agents/error-fixer.yaml << 'EOF'
name: error-fixer
on:
  error:
    new_issue: true
system: |
  Analyze this error and open a pull request with a fix.
ai_provider: claude_cli
max_turns: 15
branch_prefix: fix/agent-
deliverable: pull_request
EOF
git add .temps/agents/error-fixer.yaml && git commit -m "feat: add error-fixer agent" && git push

On the next deployment, Temps reads .temps/agents/, upserts the config into project_agents, and the AgentCronScheduler starts watching for triggers.

What Temps Replaces

Temps is a single Rust binary that self-hosts all of these:

The AI agents benefit directly from this integration: there is no API boundary between the agent and the error tracker, the session replay data, or the deployment system. When the agent fixes a bug, it can immediately see whether the next deployment resolves the error — without a webhook, a third-party integration, or an API key.

Agent capabilities are part of the active development sprint. The feat/autopilot branch has been merged and is shipping in upcoming releases.