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.
Simple, transparent pricing
Bring your own keys, bring your own compute. Pay only for the control plane.
Free / Solo
Everything you need to run verified agent work locally.
- Local CLI + TUI + self-hosted web dashboard
- Unlimited BYOK runs
- Community pipelines & registry
- Loops, firmware, memory (local)
- Full audit trail (local)
Pro
Hosted cockpit and private templates for solo professionals.
- Hosted cockpit — no self-hosting needed
- Runs, loops, costs aggregated in the cloud
- Private pipeline templates
- Priority registry sync
- Email support
Team
Collaboration, governance, and shared visibility for teams.
- Org + seat management
- Shared pipelines & registry
- Approval workflows + audit export
- Crew RBAC + Sentinel peer-approval
- SSO + team-wide cost rollup
Enterprise
Security, compliance, and dedicated support for large organizations.
- SAML/SSO
- SOC 2 compliance
- Audit export + DPA
- On-prem / VPC registry
- Policy enforcement + SLA