Give it a goal. It builds and runs the multi-tool workflow.
Terminator is an environment-adaptive orchestration skill for AI agents. You state the objective; Terminator scans the context, discovers the tools that actually exist in your environment, plans the workflow, coordinates execution, resolves blockers, verifies the result with concrete checks, and reports back in a fixed, scannable format.
Goal → Context Scan → Tool Discovery → Tool Registry → Plan → Orchestration → Execution → Verification → Report
Modern agent environments are crowded: skills, MCP servers, CLI tools, plugins, project scripts, build and test commands. For a multi-step goal, the hard part is no longer any single tool — it is choosing the right tools, sequencing them, handling what breaks, and proving the result. Terminator packages that orchestration discipline as a portable Agent Skill: one stable protocol that adapts to whatever each environment actually provides.
| A multi-step goal without orchestration | With Terminator |
|---|---|
| Tools picked ad hoc, mid-task | A Tool Registry built from what actually exists |
| Multi-step behavior improvised | A plan before execution, with fallbacks per phase |
| Full ceremony even for tiny tasks | A protocol that scales with the objective |
| "Done" is claimed, not proven | Verification bound to concrete evidence |
| Free-form output every run | One fixed report format, comparable across runs |
Terminator follows a nine-step operating protocol:
| # | Step | What happens |
|---|---|---|
| 1 | Objective understanding | Extract deliverables, constraints, sources, and completion criteria |
| 2 | Context scan | Read the working context: project type, repository state, key files |
| 3 | Tool discovery | Find the skills, MCP servers, CLI tools, scripts, and commands that exist |
| 4 | Tool Registry | Map useful tools: state, best use, risks, fallbacks |
| 5 | Plan | Design the workflow; large or ambiguous goals get the plan before execution |
| 6 | Execution | Coordinate the selected tools with minimal, reversible actions |
| 7 | Blocker handling | Resolve safely, reroute through fallbacks, or hand back to the user |
| 8 | Verification | Prove the result with tests, builds, output, or structural checks |
| 9 | Report | Return the fixed-format operational summary |
The protocol is proportional: a small, low-risk objective compresses scanning, discovery, and planning into one quick pass — but verification and the final report are never skipped. Useful discoveries outside the stated objective become recommendations, not actions.
1. Install. Copy the skill package into the skills folder used by your agent environment:
git clone https://github.com/Tire-C/terminator-skill.git
cp -R terminator-skill/skills/terminator <your-skills-folder>/terminatorOr use the included installers with your destination of choice:
bash install.sh ~/.ai/skills # macOS / Linux.\install.ps1 -Destination "$HOME\.ai\skills" # Windows PowerShellSkill-aware environments that install from a repository URL can also be pointed directly at
https://github.com/Tire-C/terminator-skill. Reload the agent session after installation.
2. Invoke with a clear objective:
Use Terminator to audit this project, fix the main blockers, and verify the result.
3. Verify the installation. Ask your agent to list its available skills — terminator
should appear. Then run a readiness check by invoking it without an objective:
Terminator
It scans the current context and answers with a short readiness message asking for the goal.
Every run ends with the same report structure. A representative result:
STATUS: Complete
OBJECTIVE: Audit the repository, fix the main blockers, verify the result.
CONTEXT: Node.js monorepo, three packages, CI failing on lint and one test.
TOOLS ORCHESTRATED: package scripts (lint, test), git, project validator.
ACTIONS: Fixed two lint errors, repaired a broken import, re-ran the failing suite.
VERIFICATION: Test suite green (42 passed), lint clean, build succeeds.
LIMITS: One flaky upstream integration test remains skipped; out of scope here.
NEXT STEP: Re-enable the skipped test once the upstream fix lands.
STATUS is always one of Complete, Partial, Blocked, or Ready (readiness check only),
so results stay comparable across runs, projects, and agent environments.
Terminator coordinates whatever operational capabilities the current environment exposes, including:
| Category | Examples |
|---|---|
| Agent capabilities | local skills, internal agent tools, plugins |
| Integrations | MCP servers, research and document tools |
| System | CLI tools, local scripts, shell commands |
| Project | build tools, test runners, project scripts, validation tools |
| Quality | diagnostics, security checks, structural validation |
Every environment is different. Terminator builds its Tool Registry from what actually exists and is authorized — it never fakes a capability.
- Proportional. The ceremony scales with the objective; small goals get a fast path, large goals get the full protocol and see the plan first.
- Evidence-bound. Success is never reported without at least one concrete check; anything unverifiable is stated openly under LIMITS.
- Scope-disciplined. Discoveries outside the objective become recommendations in the report, never silent side work.
- Read-only until it matters. Discovery and diagnosis do not mutate anything; changes happen only during planned execution.
- Vendor-neutral. No hardcoded invocation symbols, no single-agent assumptions — only the open Agent Skills format.
- Destructive, irreversible, privileged, credential-related, or mass-modification actions require explicit user confirmation before execution.
- Changes are minimal and reversible where possible; valuable files are backed up before risky edits.
- Secrets and credentials are never exposed in output.
- Blockers that need private authorization (logins, tokens, permissions) are handed back to the user instead of being worked around.
Which agents can run it?
Any environment that supports the open Agent Skills
SKILL.md format. Terminator makes no vendor assumptions.
Does it act on its own? No. The user sets the objective, sensitive actions require confirmation, and out-of-scope work is proposed, never performed silently.
What happens when a tool is missing? The Tool Registry records it as unavailable, the plan routes through a fallback, and blockers that need private authorization are handed back to the user.
Is there code to run? The skill itself is instruction-driven — no dependencies, nothing to build. The only code in this repository is the validation script that keeps the repository honest.
| Example | Objective |
|---|---|
| Project recovery | Inspect a repository, fix the main blocker, verify it runs |
| Research workflow | Research a topic and produce a structured paper draft |
| Document generation | Build a professional presentation from local sources |
| Readiness check | Invoke with no objective and get a context-aware readiness reply |
More patterns in the usage guide.
terminator-skill/
├─ skills/terminator/ # installable skill package (SKILL.md, skill.json, README.md)
├─ docs/ # specification, usage guide, tool discovery guide, release notes
├─ examples/ # worked orchestration examples
├─ scripts/ # repository validation (validate_repo.py)
├─ tests/ # validator self-tests
├─ install.sh # macOS/Linux installer
├─ install.ps1 # Windows installer
└─ .github/workflows/ # continuous validation
The installable package is skills/terminator/; its main instruction file is
skills/terminator/SKILL.md, which starts with the YAML frontmatter (name, description)
defined by the Agent Skills open standard.
The repository validates itself locally and in CI:
python -m unittest discover -s tests
python scripts/validate_repo.pyChecks: required files, SKILL.md frontmatter rules, JSON validity, version consistency across
SKILL.md, skill.json, and the changelog, and an English-only scan of public documentation.
The test suite proves the validator catches every violation class it claims to catch.
Contributions are welcome — see CONTRIBUTING.md and run
python scripts/validate_repo.py before opening a pull request. Report bugs and request
features through GitHub issues; report
vulnerabilities according to SECURITY.md.