Hi, I'm Glitch
I don't guess. I prove it.
Describe it.
Glitch ships it.
Give Glitch a goal and a verifier — it loops until it's right, and lets you watch, approve, and budget every step.
The control plane for agent work
Three primitives. One system. Verified autonomous work that you actually control.
Loop
Goal + Verifier + Budget
Define what success looks like, how to verify it, and how much to spend. Glitch runs plan, act, observe, verify in a tight loop — retrying and adapting until your verifier passes or the budget is hit.
Pipeline
Stages + Approvals + Guardrails
Break complex work into stages with dependencies, human approval gates, and cost guardrails. Each stage runs its own agent loop, producing auditable artifacts you can review before the next stage begins.
Cockpit
Watch + Approve + Budget + Audit
A real-time operator console — terminal TUI for hands-on control, web dashboard for team visibility. See every run, every cost, every decision. Approve escalations. Export the audit trail.
Built for work you can trust
Autonomy is only useful if it’s verified, governed, and observable. Glitch is all three.
Verify, don’t hope
Every run is anchored to a verifier — a test suite, an assertion, a script. Glitch loops plan → act → observe → verify until it passes or the budget is hit. No "looks done," only proven done.
Bring any model
Your keys, your models. Anthropic, OpenAI-compatible, Azure AI, OpenRouter, or a local Ollama / LM Studio — add a provider from an endpoint and switch anytime. No lock-in, no markup on tokens.
Never lose a finding
Every issue Glitch turns up — in any run, or one you add yourself — lands in one place. Duplicates are merged, each is tracked until it’s fixed, and any of them can be handed straight to an agent to resolve.
It remembers
Glitch builds a private map of your codebase and remembers decisions, conventions, and learnings across runs — so the next task starts with context instead of a blank slate.
Governed by default
Glitch checks every action before it runs — dangerous commands are caught, and the riskiest ones can require a teammate’s sign-off. Guardrails, budgets, and a full audit trail, always on.
Watch everything
A real-time cockpit — a terminal app for hands-on control and a web dashboard for the team. Live runs, cost per step, approvals when Glitch needs you, and an audit trail you can export.
From one loop to a fleet
Three things you launch, one thing the agent does for itself — same guardrails, same cockpit, all the way up.
Loop
One goal, checked
Give a goal and a way to check it’s done. Glitch keeps trying — plan, act, check — until it passes or hits your budget.
Pipeline
Big work, in stages
Break large work into stages with approvals and budgets. Pause and resume any time, with a full record of what happened.
Crew
An org that runs itself
A set of roles that runs on a schedule — kicking off work and handing it between specialists, without you in the loop.
Agent Teams
Glitch spins these up itself
When a job is too big for one agent, Glitch splits it across several — on its own, inside the same run and the same guardrails:
Work together
The agents share what they find and hand work back and forth to solve one problem together.
Split up
The agents each take an independent piece and their answers come back together, in order.
Every one inherits the same verifier loops, budgets, Sentinel governance, and audit trail — and plugs into your context and tools over MCP.
Not a coding copilot.
Editor copilots write code in your IDE. That is genuinely useful — and it is a different job. Glitch does not live in your editor. It runs autonomous work end-to-end: plan, act, verify, repeat — and proves the result meets your criteria before calling it done.
Editor copilots
- Write code alongside you in an IDE
- Autocomplete, inline suggestions, chat
- Human reviews every line
Glitch
- Runs and verifies autonomous work
- Loops until the verifier passes or escalates
- Auditable pipelines with approval gates
- Cockpit for budget, cost, and governance
How it works
From goal to verified result in four steps.
Declare your goal
Write a natural-language goal, attach a verifier (test suite, assertion, script), and set a budget. Glitch knows what "done" looks like before it starts.
Loop: plan, act, verify
The agent plans a strategy, executes actions, observes results, and runs your verifier. If it fails, it adapts and retries — automatically — until the verifier passes.
Escalate to a human
Approval gates pause the loop and notify you. Review the work, inspect artifacts, approve or reject — the agent waits. No surprises, no unattended drift.
Audit the trail
Every action, every cost, every decision is logged. Export the audit trail for compliance, retrospectives, or proof that the work was verified end-to-end.
Private beta
Request an invite
Glitch is in a small private beta while we harden it. Leave your email and we'll send an install code when a spot opens.
Simple, transparent pricing
One price for the control plane. Bring your own key and compute — your model, your token bill, no markup, no lock-in.
Glitch is in private beta. Plans below take effect at general availability — the beta is free while it runs. Request access and we'll email you an install code.
Why it's cheaper than it looks: bundled AI tools fold model usage into the subscription and bill overages on top. Glitch doesn't touch your tokens — you pay your provider directly (a cheap or local model can cost a fraction), and the price below is only the cockpit, orchestration, and governance layer.
Free / Solo
The full agent engine in your terminal — local CLI + TUI.
- Local CLI + TUI (terminal cockpit)
- Unlimited BYOK runs
- Community pipelines & registry
- Loops, firmware, memory (local)
- Full audit trail (local)
Pro
Adds the hosted web dashboard + private templates for solo pros.
- Hosted web dashboard (the cockpit)
- Runs, loops & costs aggregated in the cloud
- Private pipeline templates
- Priority registry sync
- Email support
Team
Collaboration, governance, and shared visibility. From 2 seats.
- Everything in Pro, for your whole team
- Org + seat management
- Crew RBAC + Sentinel peer-approval
- Approval workflows + audit export
- SSO + team-wide cost rollup
Enterprise
Security, compliance, and dedicated support at scale.
- Everything in Team
- SAML/SSO + SOC 2
- DPA + full audit export
- On-prem / VPC registry
- Policy enforcement + SLA