A control plane for daily agent work.
Agentify is a layer that sits between your repo and your AI agent. It indexes the codebase, writes agent-facing context, manages sessions, runs validation, and ships a library of reusable skills for the engineering loop.
Repo readiness
Inspects the repository and prepares agent-facing docs (architecture, PRD, summary) so the agent doesn't rediscover everything.
Context routing
Resolves the right files, conventions, and prior decisions for the task at hand — keeping prompts small and answers grounded.
Skill library
A reusable set of skills for planning, PRs, triage, TDD, refactors, handoffs — invocable by name in any session.
Session state
Tracks the active task, open worktrees, and validation status so the agent can resume cleanly between turns.
Validation gates
Runs lint, types, and tests where applicable before declaring a change done — fewer "looks fine" surprises.
Multi-host delivery
Works across GitHub, GitLab, Azure DevOps, and Jira through their CLIs — issues, PRs, and tickets stay where the team works.
Stop re-explaining your repo on every turn.
A model is only as useful as the context it walks in with. Without scaffolding, every session starts cold — and small, repeated tasks become expensive.
Cold-start every conversation
Re-paste files, re-state conventions, re-explain the goal. Half your prompt is setup.
Context is already routed
Agent-facing docs and prior decisions are loaded automatically; you describe the task, not the repo.
One-off prompts, lost workflows
Useful patterns live in chat history nobody can search; they vanish next week.
Workflows as durable skills
Repeated patterns become named skills — invokable by anyone, versioned in the repo.
"Looks fine" without checks
Agent claims done, but lint, types, or tests would have flagged it. You catch it in review.
Validation before handoff
Skills that change code run the repo's checks before reporting success. Fewer round-trips.
Parallel work collides
Two agents on the same checkout step on each other; merging is a chore.
Worktree-aware sessions
Each task lands in its own worktree with merge-back commands; isolation by default.
Four steps from intent to merged change.
Drop Agentify into a repo, point it at your agent host, and the loop runs end-to-end. Each step is opt-in; nothing is magic.
Index the repo
Agentify scans the codebase, extracts architecture and conventions, and writes agent-facing docs. The agent walks in with a map, not a torch.
agentify init
Install the skills you need
Pick from a library of reusable skills — implementation, planning, PRs, triage, TDD. Scoped per project so the team shares the same vocabulary.
gh skill install ixigo/agentify skills/auto-pilot --agent codex --scope project
Invoke a skill, not a prompt
Call skills by name in your session. Agentify routes the right context, runs the workflow, and isolates the change in a worktree when needed.
implement <goal> · triage #42 · open-pr
Validate, commit, hand off
The skill runs the repo's checks before reporting done, drafts a Conventional commit, and returns merge-back or PR commands. You stay in control of the publish step.
commit · open-pr · copy-pr