AI-KIT

Stop re-explaining your project to every new AI chat.

AI-KIT gives your coding agents persistent project memory, expert stack rules, Kubernetes-ready container guidance, an adaptive model routing policy, and native entry files and configuration for 11 AI clients. Add Cloudflare security-audit for structured security review and Strix for scoped pentesting workflows. One offline installer, zero installer dependencies, changes previewed before you apply them.

What changed in each release: CHANGELOG.

v1.6.0: English chat defaults, Devin (Windsurf), JavaScript/Node.js, optional UUIDs and human Claude GitHub identity. Release verification and publication status.

Published and verified: PyPI ai-kit-python 1.6.0 installs from the public index; Docker Hub tigusigalpa/ai-kit:1.6.0 passed an immutable pull and offline checks. Both carry the same 319 packaged source files. Checks, hashes and digest.

Get AI-KIT · Update AI-KIT · Defaults · Features · Honest boundaries · Quick start · Docs site · Guides · Install guide · CLI flags · Windows · Docker

Python package (recommended). Requires Python 3.10+; no mandatory third-party runtime dependencies.

pipx install ai-kit-python
aikit --version

The PyPI package is ai-kit-python; the command it installs is aikit. Never run pip install aikit: that is not this project's package name. Without pipx, run python -m pip install ai-kit-python inside a virtual environment. On Windows, the Windows guide covers PATH and interpreter problems.

Docker image. tigusigalpa/ai-kit runs the same CLI without host Python (linux/amd64). Image tags follow the repository VERSION of each release and there is no latest tag, so pick a version from the tags page, for example the verified 1.6.0:

docker pull tigusigalpa/ai-kit:1.6.0
docker run --rm tigusigalpa/ai-kit:1.6.0 --version

Project mounts, preview/apply examples and the runtime contract are in Run AI-KIT with Docker.

Source checkout (alternative).

git clone https://github.com/tigusigalpa/ai-kit.git
cd ai-kit
python scripts/install.py --help

From a checkout, run python scripts/install.py or python aikit_cli.py COMMAND directly, or run python -m pip install . there to get the aikit command. Details: Get the CLI.

1. Update the Python package. If you installed with pip, run this using the same Python environment as the existing installation (activate its virtual environment first if applicable):

python -m pip install --upgrade ai-kit-python
python -m aikit.aikit_cli --version

The package name is ai-kit-python, not aikit. The module-based version check works even when aikit.exe is missing from PATH. If you installed with pipx, use this instead:

pipx upgrade ai-kit-python
aikit --version

These commands install the newest version published on PyPI; unreleased source changes become available there only after a release. They update the CLI without rewriting the AI-KIT files already installed in your application projects.

2. Update each application project separately. Open a terminal in that project's root folder (. means the current directory), inspect the preview, then apply the update and run its health check:

python -m aikit.aikit_cli install .
python -m aikit.aikit_cli install . --apply --check

For a pipx installation, use aikit install . and then aikit install . --apply --check. Omit --agent, --mode and module flags when you want to retain the project's saved choices. Existing project documents and local adaptations follow the preservation/conflict rules; review reported candidates before accepting a manual merge. Updating the CLI once does not automatically update every project.

For Docker, choose and pull an explicit new version tag and rerun the installer against the project mount; there is no latest image. Full update and conflict guide · Windows troubleshooting · Docker instructions.

aikit install /path/to/my-app --chat-language Russian --conventions standard

AI-KIT preserves facts and decisions, points agents at real checks and records authorization boundaries:

• Project knowledge: manifests draft module facts and commands; bootstrap verifies them.
• Stack depth: relevant profiles cover framework authorization, transactions, cancellation, privacy and infrastructure review.
• Your authority: explicit commits/pushes, optional risky-command guards and secret exclusions.
• Visible evidence: unavailable checks remain unverified.

flowchart LR
    A[aikit install preview] --> B[apply]
    B --> C["/ai-kit-bootstrap"]
    C --> D[plan → implement → test → review → document]
    D --> E["/ai-kit-sync-context"]
    E --> D

• Verified context: PROJECT_CONTEXT and project.json hold contracts, module facts, commands and unknowns.
• Manifest drafts: Go, Composer, Node, Python and Moodle evidence suggests versions and module commands until bootstrap confirms them.
• Session start: an optional Claude hook reads context and Git status.
• Continuity: decisions, ADRs and changelog preserve reasons; the continuity skill keeps context and pointers synchronized.

What lands in your project

Profiles combine per module, so a monorepo with a Laravel app in web/ and a Go service in api/ gets the right rules in each place. Opinionated owner conventions for Laravel (no database foreign keys, Policy + Factory + Seeder per model, one table per migration, Filament 5+ for new panels) are the default; use --conventions standard to follow your project's own conventions instead. Public UUID guidance is an independent opt-in; see optional UUIDs and Claude GitHub identity.

The kit instructs agents to make new Dockerfiles and services Kubernetes-ready, following the Kubernetes-ready contract, including local Docker Compose projects:

• Images/runtime: pinned multi-stage images, build secrets outside layers, non-root execution, read-only root, exec entrypoints; no privileged mode or Docker socket.
• Lifecycle: startup/readiness/liveness probes, SIGTERM drain, migrations in separate Jobs.
• Deployment: ConfigMap/Secret, stdout logs, stateless replicas, PVCs where needed, dropped capabilities, seccomp and resource requests.
• Preflight/cleanup: verify Docker client/daemon; after every Docker task remove eligible disposable containers, volumes, networks and superseded test images. The default maximum mode also removes the dedicated builder and its cache, without a size threshold, and reclaims host RAM/disk; --docker-cleanup keep-cache keeps the builder cache. Cleanup modes and host reclamation.

The routing policy recommends a model role and reasoning effort for each task on a 0-6 capability ladder: the cheap role for classification and narrow mechanical edits, the work role for engineering and hard debugging, escalation after a diagnosed capability shortfall. Provider configurations map roles to OpenAI, Anthropic, Kimi, and Gemini models, or your own local/Ollama models. The offline helper understands English and Russian task descriptions and explains its choice:

aikit route "debug a race condition in the queue worker"

It is a recommendation, and no cost savings are claimed. The kit never fakes a model switch: when a client offers no switching control, you get a recommendation. Levels, providers and configuration.

Scoped rules, ignore files, and settings come with the native-settings and scoped-rules extras. The preview spots the clients you already use from existing files and suggests the matching --agent list. Copying files does not prove that a client discovers or activates them, and documentation for Kimi and Manus is unverified; aikit adapters report --project TARGET lists each client's documentation status.

For a new Codex + Claude + Devin (Windsurf) setup, run this from the application directory:

python -m aikit.aikit_cli install . --agent codex --agent claude --agent devin --mode private --preset strict --with-security-audit --with-strix --with-context7 --with-web-design --with-claude-github --apply --check

Add --with-uuid only if the project should adopt public UUID guidance. Explicit --agent flags describe the complete selection; include every client you want to keep. To move an existing installation from windsurf to devin, temporarily include both adapters in the full selection and preview/apply it. Then preview aikit adapters retire . --agent windsurf and repeat with --apply after review; the retirement removes only unchanged owned legacy rules and deselects windsurf. Edited legacy rules remain conflicts and are preserved. Devin loads both rule directories, so inspect overlapping rules before using it. The supported current paths and legacy imports are documented in Devin Local customizations; --agent devin targets the local/desktop rule format.

All Claude installations include the baseline human-authorship rule and request attribution.commit as an empty string in their managed local/team settings. This suppresses Claude's commit-credit trailer; it does not change Git's author fields. Existing custom attribution values produce a reviewable conflict instead of being overwritten. Existing human co-authors, signing and PR-attribution preferences are preserved. Claude attribution reference.

Example: add both policies to an existing project while preserving its saved client selection:

python -m aikit.aikit_cli install . --with-uuid --with-claude-github
python -m aikit.aikit_cli install . --with-uuid --with-claude-github --apply --check

The GitHub policy needs Claude selected; add --agent claude alongside the full desired client list when necessary. Nothing logs in, queries GitHub, changes global Git settings, commits or pushes during installation. These flags persist across upgrades. Omitting them later does not disable them; review and set uuid or claude_github to false in ai-kit/settings.json to deselect. Existing files/data remain preserved. Changing a setting never authorizes destructive schema changes or a Git operation.

TypeUI supplies design guidance; the coding client implements it in your project. AI-KIT supplies the brief, project memory and acceptance workflow. Adding --with-web-design installs those local resources; registering and authenticating the TypeUI MCP server is a separate step. The commands below configure the clients you run them in, rather than the AI-KIT Docker container. The hosted service is not bundled or revision-pinned by AI-KIT.

Open a terminal in the application directory. Install/update AI-KIT, selecting the full client list you use; preview first by omitting --apply --check:

python -m aikit.aikit_cli install . --agent codex --agent claude --with-web-design --apply --check

Keep an already-selected --agent devin or other client in that list if needed. Fill docs/design/BRIEF.md with the goal, audience, required pages/sections, content, reference URLs, assets, supported screen sizes and constraints. Put the approved visual direction in docs/design/SYSTEM.md and measurable checks in docs/design/ACCEPTANCE.md. Existing documents are preserved; review actual frameworks and versions before asking for implementation.

Check that the Codex CLI is available with codex --version, then register the official HTTP endpoint:

codex mcp add typeui --url https://mcp.typeui.sh/mcp
codex mcp list
codex mcp login typeui

Complete the sign-in in the browser yourself. Start/reopen Codex and use /mcp in its terminal interface to inspect the active connection. In an IDE extension, inspect MCP servers and restart the extension after configuration changes. Listing a server proves registration; a successful authenticated tool call proves the current connection. TypeUI's Codex guide · OpenAI MCP configuration and authentication.

For project-scoped configuration, merge this table into the existing .codex/config.toml instead of replacing the file or creating a duplicate table:

[mcp_servers.typeui]
url = "https://mcp.typeui.sh/mcp"

Keep credentials out of that file and the repository; the client handles sign-in separately. Check which configuration is effective in the client you actually use. A remote/web session does not inherit a local process's configuration automatically.

From the same application directory, check claude --version and add the HTTP connection at the private, current-project scope:

claude mcp add --transport http --scope local typeui https://mcp.typeui.sh/mcp
claude mcp list
claude

Inside Claude Code, enter /mcp, choose typeui, authenticate and finish the TypeUI sign-in. The local scope is stored under the project's entry in your personal ~/.claude.json. For a team-shared endpoint use --scope project instead; Claude writes .mcp.json, and each teammate authenticates separately. Review an existing registration before adding another with the same name. TypeUI's Claude guide · Claude MCP scopes.

This example targets Claude Code. A Claude chat/desktop connector has its own setup; registering a CLI connection does not automatically configure every Claude application.

Ask the client to inspect available TypeUI tools and check sign-in/access before generation. For the currently exposed tools, typeui_check_access and typeui_get_usage provide the access/usage checks. An account or plan requirement must be resolved in TypeUI; AI-KIT does not supply access or promise a free quota.

For a custom visual system, create or import a draft in TypeUI, review its Markdown, then publish it for MCP. Choose one visual system for the task. Keep AI-KIT's engineering/acceptance rules and reconcile conflicting visual instructions before generating. Follow TypeUI's MCP workflow for the current account and publishing steps.

In Codex use $web-design; in Claude Code use /web-design. Supply a concrete request such as:

Use the web-design workflow and the connected TypeUI tools.
Read docs/design/BRIEF.md, SYSTEM.md and ACCEPTANCE.md first.
Confirm the actual framework and package versions. Reuse the existing application.
Check TypeUI access, then prepare one approved visual direction.
Propose the page structure and implement the hero section first.
Review responsive behavior, keyboard access and real browser output.
Continue after that section meets the acceptance criteria.
Do not deploy or replace the project's tooling without an explicit request.

Treat generated prompts as design inputs under the project's instructions. Review any returned skill-install command before executing it; choose a project-local location and inspect existing files. For a multi-section TypeUI workflow, complete the requested cleanup/acceptance for the current section before asking for the next one. Record only reviewed decisions in the design documents. A generated layout still needs the project's actual build/tests and browser review.

These instructions are source-checked setup guidance. Live authentication and generated-site acceptance must be verified in the target clients.

• Recorded checks: Claude Code allow rules for the recorded test/lint/build commands (with --with-native-settings).
• Secret exclusions: shared lists cover env files, keys, Composer auth, Laravel/Moodle credentials and .pypirc through selected client deny/ignore controls.
• Module scope: native rules select relevant guidance by file path (with --with-scoped-rules).
• Owned entries: Claude settings merge by key, using local settings in private mode and moving only kit entries on mode switches.

These guardrails reduce risk through instructions, client ask/deny rules and ignore files. They are not a security boundary or a sandbox.

• No surprise commits. Commits and pushes require your explicit request, and optional Claude Code ask rules back that up.
• Confirmation before damage. With data guards, Claude Code asks before rm -rf, git reset --hard, git clean, a Docker prune, or a Laravel/Moodle migration.
• Secret files. Deny rules and ignore files discourage reads of common secret files in clients that honor them; they do not encrypt or lock those files.
• Security baseline: input validation, server-side authorization, and no secrets in code, logs, or prompts. Dependency audits run per stack with composer audit, govulncheck, pip-audit, and your package manager's audit.
• Honest verification: unavailable tools, services, or CI are reported as unverified, never as passed.

Every task follows plan → implement → test → review → document, with staged migrations and rollback plans, review by concrete scenario and severity, and a changelog entry for every change. Owner conventions add a Codecov gate of at least 90% of changed lines when Codecov is configured. Three user-invoked skills make the routine instant:

• /ai-kit-bootstrap confirms installer drafts and fills context from real evidence.
• /ai-kit-review reviews current changes against the engineering and security rules.
• /ai-kit-sync-context updates context, decisions, and the changelog after work.

In Codex, use $ai-kit-bootstrap and the other skills the same way.

Both are off by default, pinned to reviewed upstream revisions and invoked explicitly. Installation copies files only: it runs no audit or scan, and a Strix scan needs its own CLI, Docker, model access and authorized targets. Security workflows guide.

Give your agent the sites you like, a short brief and the target project. The optional module (--with-web-design) organizes that material into one visual direction, reusable components and a working interface with recorded checks, with a detailed Laravel/Blade route and conditional guidance for Tailwind, Bootstrap, Alpine, Livewire, daisyUI, Flowbite and Flux. It installs no external tools and generates or deploys nothing by itself. Web Design guide: implementation routes · tools, review and troubleshooting.

The optional context7-docs workflow (--with-context7) checks the dependency version, resolves the library, retrieves focused examples and records source/coverage gaps. MCP connection and authentication stay separate. Context7 guide.

The offline aikit memory command imports two conversations, preserves their sources, shows contradictions for your review and exports the same reviewed reference state as ChatGPT Markdown and an OpenRouter request fragment. It uploads nothing and needs no API key. Dialogue context guide.

--with-orchestration adds scoped Codex helper agents and a disabled-by-default, bounded OpenRouter text executor with explicit apply, capped-key preflight, private accounting and review. Installation launches no agents and makes no paid calls. Orchestration guide.

AI-KIT rules, project facts and selected context can travel with your API requests; the guide covers request layout, prompt and response caching, and measuring actual usage. OpenRouter guide.

The tigusigalpa/ai-kit image runs the installer and helpers with a read-only root, no network and an explicit project mount: preview with a read-only mount, then apply with a writable one. Docker guide.

aikit benchmark runs isolated A/B/C trials through a reviewed worker, aikit route --mode adaptive recommends from comparable history, and aikit context select selects module rules within a byte budget. Measurement guide.

• Language/sharing: English files and chat by default; saved project languages remain unchanged on upgrades. Private or team instructions. Sharing.
• Health: aikit doctor TARGET reports managed-file, link, provider and context drift and names the upgrade commands when a newer AI-KIT is available; --fix previews a repair plan and --fix --apply writes it, preserving local edits. An older CLI refuses to downgrade a newer installation unless you pass --allow-downgrade.
• MCP review: aikit mcp report TARGET lists MCP servers from project client files with transports, commands and variable names, never secret values, and warns about literal credentials, plain remote HTTP and auto-approval. Details.
• CI: --with-ci adds a workflow that validates the committed AI-KIT files; it does not clone or install AI-KIT and is meaningful in team mode.
• Measurements: aikit metrics records supplied attempt/token/cost evidence and analyzes provider results. No automatic telemetry; evaluation checks opaque pair coverage.

• Installation copies files. It runs no audit, scan, model call, cleanup or external tool setup; optional modules need their own tools, credentials and authorization.
• Client activation is unverified. AI-KIT writes native entry files and configuration; whether a client discovers and applies them must be checked in that client. Documentation for Kimi and Manus is unverified.
• Routing recommends. Confirm actual client controls; no cost savings are claimed.
• Guardrails reduce risk. Permission rules and ignores are not a security boundary.
• Measurement needs evidence. The benchmark requires its own reviewed protocol worker. Optional OpenRouter text execution is separately enabled and explicitly applied; native client activation and end-to-end savings require independent verification.
• CI checks files, not behavior. The --with-ci workflow validates committed AI-KIT files only; it does not run your application's tests.

Quick start in three steps.

Use an application folder outside any AI-KIT checkout.

1. Preview. Nothing is written:

aikit install /path/to/my-app --preset solo --agent codex --agent claude

On Windows use a path like "C:\Projects\my-app". The preview lists writes, preserved files, conflicts, and detected stacks/clients. Add --chat-language English --conventions standard here and in step 2 to change the defaults.

2. Apply the same command with --apply; add --check to run the doctor right away:

aikit install /path/to/my-app --preset solo --agent codex --agent claude --apply --check

3. Bootstrap. Open your AI client in the project and run /ai-kit-bootstrap (Claude Code) or $ai-kit-bootstrap (Codex). For other clients, give it BOOTSTRAP_PROMPT.md.

Existing project documents and context are never overwritten; customized instructions become reviewable conflicts. From a source checkout, python scripts/install.py takes the same arguments; in Docker, see preview and apply.

• Documentation site: an interactive command configurator, CLI installation for Windows and Linux/macOS, post-install commands and a searchable flag reference, in English and Russian
• All guides
• Install AI-KIT and set up a project: CLI, defaults, presets, what lands in your project, sharing, updates
• Installer flags and options, also as JSON via aikit flags
• Windows: installation and troubleshooting
• Run AI-KIT with Docker, including Docker cleanup and host reclamation
• Security workflows, Web Design, Context7, shared dialogue context
• Optional orchestration, working with OpenRouter, measurement and context selection
• CHANGELOG · SKILL.md · CONTRIBUTING.md · SECURITY.md · License

The repository is a skill: SKILL.md covers installation, configuration, upgrades and maintenance. For Claude Code, clone into your skills directory:

git clone https://github.com/tigusigalpa/ai-kit.git ~/.claude/skills/ai-kit

For other assistants, share the repository or SKILL.md.

Applications install from template/; the root maintains AI-KIT itself. Before contributing, run:

python scripts/check_kit.py
python -m unittest discover -s tests -v

See CONTRIBUTING.md and the maintainer guide for local maintainer files, publication copy and the PyPI release procedure.

AI-KIT is released under MIT; bundled Cloudflare references retain MIT and Strix references retain Apache-2.0. Choose and verify your application's license separately.