Platform Features
Memory, governance, and collaboration for AI‑assisted engineering
Your team ships with AI agents every day — and every decision behind the code evaporates when the session ends. crewkit remembers it, injects it, and makes it searchable, so every session starts where the last one left off.
01 / remember
Remember
Team Memory That Outlives the Session
Institutional knowledge shouldn't live in one person's head. Upload PRDs, transcripts, contracts, and design docs; import from Google Drive; capture Slack threads as project artifacts. Everything becomes semantically searchable project memory — and it is injected automatically when a session starts.
A developer working on the auth module gets the auth PRD and API contract without asking. A developer refactoring the database layer gets the data model spec. The meeting where the decision was made, the thread where it was debated — the agent already knows.
Every analyzed conversation is indexed too. Ask "has anyone touched this before?" and find the actual session that did the work. Sensitive and private sessions stay privacy-gated.
- Upload anything — PRDs, transcripts, contracts, design docs, API specifications — all indexed for semantic search
- Drive import and Slack capture — Import from Google Drive, or capture Slack and email messages as artifacts — human-confirmed before they are ever injected
- Automatic context injection — Relevant artifacts load into every session at start, matched by project and topic
- Find prior work — Every analyzed conversation is searchable, so past sessions answer questions too — privacy-gated for sensitive and private work
Complete Session Hierarchy With Import
Every AI coding session in crewkit follows a two-level hierarchy: Conversations capture the primary interaction developers see, and Tasks track work delegated to specialized agents. This structure gives teams both a high-level overview and the ability to drill into any detail.
Any session is one share link away. Create access-controlled links with organization or public visibility and optional expiry, and annotate specific moments inline — so a developer can hand a teammate the exact exchange where a fix clicked, and a manager can review how the team actually works with AI. Share from the dashboard, or from the CLI with a single keystroke.
Teams migrating to crewkit can import their historical sessions from JSONL exports. The import pipeline deduplicates by session ID, parses model metrics, and indexes everything for search. Thread grouping connects related conversations, so multi-session workflows stay coherent.
- Two-level hierarchy — Conversation and Task levels give both overview and drill-down capability
- Session sharing — Access-controlled links with org or public visibility and expiry, plus inline annotations — one keystroke from the CLI (F12+s)
- Historical import — Import past sessions from JSONL. Deduplication, metric parsing, and search indexing included.
- Thread grouping — Related conversations are grouped into threads for multi-session workflow tracking
A Marketplace of Agents, Skills, and Playbooks
Stop building everything from scratch. crewkit ships with a growing library of production-ready resources — agents tuned for specific frameworks, skills that codify repeatable workflows, and playbooks that encode your team's engineering standards.
Every resource uses 3-tier inheritance: Platform resources provide a curated baseline, organizations layer on team-specific guidelines, and projects add repository context. Change a resource at one tier and it propagates to every downstream consumer automatically.
Resources are versioned with immutable snapshots. Roll back to any previous version, fork a platform resource to customize it, or promote your own to the organization catalog. Your knowledge compounds — privately: every version measured and every session attributed makes your team's setup sharper, and none of it leaves your organization.
- Curated resource library — Agents for Rails, React, DevOps, security, database migrations, and more — ready to install
- 3-tier inheritance — Platform, Organization, and Project tiers compose and override cleanly. One change propagates everywhere.
- Per-version attribution — Every session records the exact version of every agent and skill that ran. Cost, tokens, and quality scores roll up per version — you know precisely which change helped.
- Share across your org — Promote proven configurations from one project to the whole organization. Your catalog is yours alone — nothing is published outside your org.
02 / govern
Govern
Playbooks That Enforce Your Engineering Standards
Playbooks codify your team's engineering standards into enforceable conventions that agents follow automatically. Define your testing strategy, naming conventions, architecture patterns, and code style once — and they propagate to every AI session across the organization.
crewkit's AI-powered convention extraction can analyze your existing codebase and generate playbook conventions from the patterns already present. Instead of writing standards from scratch, let crewkit discover what your team already does well and codify it. Stack-based matching ensures Rails projects get Ruby conventions and React projects get TypeScript conventions.
When an agent deviates from a convention, the challenge is logged — then resolved to an accept or override outcome. Analytics show which conventions get overridden most and which need review, and error-severity conventions block outright. Governance you can audit, not a doc nobody reads.
- AI-powered extraction — Analyze your codebase to discover and codify existing patterns into playbook conventions
- Stack-based matching — Rails, React, Python, Go, and more — conventions auto-match to the right projects
- Auditable challenge log — Deviations are logged as challenges and resolved to accept or override outcomes — with analytics on which conventions need review
- Subscribe and assign — Adopt platform playbooks or build your own, then assign them per project so every repo enforces what fits
Governance That Scales With Your Team
Not every developer should interact with AI the same way. crewkit's role-based agent configuration lets you define how agents behave for different team members. Junior developers get coaching mode — agents guide them, explain concepts, and ask clarifying questions. Senior developers get autonomous mode with full implementation capability.
Organizations define custom roles mapped to agent behavior modifiers. A "junior" role might activate coaching mode on all agents, while a "tech-lead" role enables autonomous mode with architecture-level prompts. Roles are assigned per member and enforced automatically in every session.
Every modification is tracked through audit trails: who changed what, when, and why. Security events are logged for compliance. And detection is privacy-first — test-quality scoring and convention-drift detection run deterministically on session telemetry, with no code egress and no LLM in the loop. This is the governance layer that regulated industries need for AI-assisted development.
- Role-based behavior — Coaching, collaborative, and autonomous modes tailored to developer seniority
- Custom roles — Define organization-specific roles with granular agent behavior modifiers
- Audit trails — Every change is tracked automatically. Security events logged for compliance requirements.
- Convention enforcement — Measure adherence to standards across the organization with an auditable challenge log
- Privacy-first detectors — Deterministic test-quality scores and convention-drift detection on session telemetry — no code egress, no LLM in the loop
Full Visibility Into Every AI Session
crewkit captures comprehensive telemetry from every AI coding session — tokens consumed, costs incurred, models used, tools invoked, session duration, turn counts, and outcome quality. All of this data flows into dashboards built for engineering leaders who need answers, not just data.
The analytics suite includes four specialized views: a summary dashboard with KPI cards, timeseries charts showing trends over any time range, per-agent breakdowns revealing which agents perform best, and cost analysis by model showing exactly where your budget goes. Filter by project, developer, agent, or time range.
Sessions are automatically analyzed by AI for quality scoring, generating coaching tips, identifying patterns, and summarizing outcomes. This transforms raw telemetry into actionable insights that help teams improve their AI-assisted workflows week over week.
- Session telemetry — Turns, tokens, costs, tool usage, duration, and model breakdown per conversation
- Four analytics views — Summary KPIs, timeseries trends, per-agent performance, and cost breakdown by model
- AI-powered analysis — Automatic session summaries, quality scores, coaching tips, and pattern detection
- Filter and drill down — Slice data by project, developer, agent, time range, or any combination
A/B Test Agent Configurations Like You Test Code
Tweaking a prompt should not be guesswork. crewkit's experimentation framework lets you run controlled A/B tests on any resource version — agents, skills, playbooks, or rules. Split traffic between control and variant, then let real usage data determine the winner.
Every experiment tracks session-level metrics: quality scores, cost per session, token efficiency, and turn counts. crewkit computes statistical significance using p-values and confidence intervals, so you deploy changes only when the data confirms improvement — not when it feels right.
When an experiment reaches significance, crewkit generates a recommendation: upgrade to the variant, roll back to control, or collect more data if results are inconclusive. The winning version can be deployed to the full team with a single action, completing the improvement loop.
- Controlled experiments — Split traffic between resource versions with automatic, unbiased assignment
- Real-time metrics — Track quality scores, cost, token efficiency, and turn counts live
- Statistical significance — p-values and confidence intervals ensure you deploy only proven improvements
- Automated recommendations — Upgrade, rollback, or collect more data — crewkit tells you what to do next
03 / collaborate
Collaborate
Agents as Teammates, Work in the Open
Give an agent a Slack handle scoped to your project. @mention it in a thread and it replies in-thread, with full project context — the PRD, the conventions, the prior sessions. Agent email inboxes are coming soon.
Teammates see each other's active conversations and claimed blueprint tasks live, so nobody steps on anyone's work. Who is on what is a glance, not a standup question.
And any session is one share link away — organization or public visibility, optional expiry, and inline annotations to highlight the exchange that matters.
- Agent Slack teammates — Project-scoped agents with their own Slack handle. @mention one and it answers in-thread with project context.
- Live active work — See teammates' open conversations and claimed blueprint tasks per project, in real time
- One-link session sharing — Share from the dashboard or the CLI (F12+s), annotate inline, and control visibility and expiry
- Org-wide shares view — My shares and Shared with me in one place, so shared knowledge stays findable — not lost in DMs
A Living Plan Linked to the Real Work
Blueprints are the shared plan for a project — epics for major workstreams, tasks for atomic units of work, and dependencies between them. Not a document that goes stale: a plan that tracks reality.
Tasks link to the actual conversations that did the work. When someone asks what happened with a task, the answer is the session itself — decisions, costs, and outcome included.
An AI co-pilot chat helps you shape the plan with full knowledge of blueprint state, and the CLI sidebar keeps the blueprint visible while you code.
- Epics and tasks with dependencies — Break work into ordered, dependency-aware units the whole team can see
- Linked to real sessions — Tasks connect to the conversations that did the work, so the plan reflects what actually happened
- AI co-pilot chat — Plan with an assistant that knows your blueprint's current state
- Visible from the CLI — The TUI sidebar shows blueprint state alongside the session while you work
Pre-Built Agents for Every Part of Your Stack
Agents are the core of crewkit. Each agent is a specialized AI configuration tuned for a specific domain — Rails backend work, React frontend architecture, security reviews, database optimization, API design, and dozens more.
When a developer starts a session, crewkit syncs the right agents for the project. The agent receives the full context chain: platform-level best practices, organization coding standards, and project-specific conventions. No manual configuration. No copy-pasting prompts.
Agents adapt to each developer's role. Junior engineers get coaching mode — the agent guides them step by step, explains concepts, and asks clarifying questions instead of writing code directly. Senior engineers get autonomous mode with full agency. Collaborative mode sits between, pairing on solutions together.
- Domain-specific agents — rails-expert, frontend-expert, security-expert, api-designer, devops-engineer, and more
- Role-based behavior — Coaching, collaborative, and autonomous modes adapt agent output per developer seniority
- Task delegation — Agents delegate subtasks to specialized agents. Every delegated task is tracked with its exact resource version.
- Context injection — Project context, conventions, artifacts, and team standards are loaded automatically into every session
Reusable Skills That Codify How Work Gets Done
Skills are reusable capability modules that extend what AI agents can do. Instead of ad-hoc prompting, skills encode repeatable workflows — committing code, reviewing pull requests, planning features, running QA checks, writing documentation, and more.
When a developer invokes a skill, crewkit records the invocation with the exact resource version used — silently, in the background, with no ceremony in the terminal. This creates an auditable trail of which skill version produced which output, so teams can measure skill effectiveness and iterate on the workflow definition.
Skills compose with agents. A developer working with the rails-expert agent can invoke the /commit skill, which follows team conventions for message format, runs pre-commit checks, and stages the right files. Skills turn tribal knowledge into automated workflows anyone on the team can use.
- Pre-built skill library — /commit, /review-pr, /plan-feature, /qa, /refactor, /document, and dozens more
- Invocation tracking — Every skill use is recorded with the exact resource and version for full traceability
- Composable with agents — Skills work alongside any agent. The agent provides domain context, the skill provides the workflow.
- Custom skills — Build org-specific skills for your deployment process, migration patterns, or review standards
A CLI Built for How Developers Actually Work
crewkit lives where developers work — the terminal. The CLI ships as a single fast native binary — instant startup, no runtime dependencies — with a TUI (terminal user interface) that displays session metrics, summaries, and git context in a sidebar alongside the AI conversation. Zero-config setup means a single install and crewkit code gets you running.
The leader key system (F12 + second key) provides a namespace of keyboard shortcuts that never conflict with the AI assistant or terminal. F12+p opens the command palette for fuzzy-searching all available commands. F12+i shows session info. F12+d opens the dashboard for the current conversation.
Progressive onboarding means crewkit code handles everything inline — authentication, project initialization, and resource sync happen automatically on first run. No separate setup commands, no configuration files to edit, no dead ends. The CLI detects the git remote, resolves the project, and starts the session with full context.
- Zero-config setup — Install, run crewkit code, and you are working. Auto-detects org and project from git.
- TUI with sidebar — Session metrics, AI summary, git context, and cost tracking visible alongside the conversation
- Leader key system — F12+key shortcuts for command palette, session info, sharing, and dashboard — no conflicts
- Progressive onboarding — Auth, init, and sync happen inline on first run. Never dead-ends. Always recoverable.
Fits into your existing workflow
crewkit integrates with the tools your team already uses. No workflow changes required — just better memory and control.
MCP Server
crewkit's memory works wherever your agents do. Works with Claude Code today; any MCP-capable agent can pull project context, conventions, prior work, and blueprint state.
Git Integration
Auto-detects repositories and branches. Sessions track git context including branch, SHA, and component.
CI/CD Ready
Resource sync works in CI pipelines. Validate agent configurations as part of your deployment process.
API-First Design
Full REST API for custom integrations. Build dashboards, automations, or connect to your existing tools.
Multi-Repo Support
Workspace projects span multiple repositories. Mono-repos and multi-repo architectures both work seamlessly.
Built for the full AI development lifecycle
From first install to production optimization, crewkit covers every stage of AI-assisted engineering.
Live Active Work
See who is in which conversation and which blueprint tasks are claimed — per project, live, not after the fact.
Multi-Tenant Isolation
Complete data isolation ensures organizations never see each other's data. Enterprise-grade access controls enforce separation.
Modern Authentication
Passkeys, magic links, and device flow. Security events audited.
Keyboard-First UX
Leader keys, command palette, and shortcuts. Designed for developers who live in the terminal.
Command System
Reusable commands that any developer can invoke. Shared across the organization with versioning.
Dashboard + CLI
Power users stay in the terminal. Managers use the web dashboard. Same data, two interfaces.
Native CLI Binaries
A single fast native binary for macOS, Linux, and Windows — instant startup, no runtime dependencies. Public releases and issue tracker on GitHub.
Continuous Improvement
Configure, sync, measure, iterate. Your agents get measurably better every sprint.
Nothing your team decides gets lost.
Memory, governance, and collaboration in one layer — working from your first crewkit code.
Free tier includes 1 seat, 2 projects, and 500 sessions/month. View pricing