Great work.
Nothing lost.

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 anythingPRDs, transcripts, contracts, design docs, API specifications — all indexed for semantic search
• Drive import and Slack captureImport from Google Drive, or capture Slack and email messages as artifacts — human-confirmed before they are ever injected
• Automatic context injectionRelevant artifacts load into every session at start, matched by project and topic
• Find prior workEvery 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 hierarchyConversation and Task levels give both overview and drill-down capability
• Session sharingAccess-controlled links with org or public visibility and expiry, plus inline annotations — one keystroke from the CLI (F12+s)
• Historical importImport past sessions from JSONL. Deduplication, metric parsing, and search indexing included.
• Thread groupingRelated 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 libraryAgents for Rails, React, DevOps, security, database migrations, and more — ready to install
• 3-tier inheritancePlatform, Organization, and Project tiers compose and override cleanly. One change propagates everywhere.
• Per-version attributionEvery 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 orgPromote proven configurations from one project to the whole organization. Your catalog is yours alone — nothing is published outside your org.

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 extractionAnalyze your codebase to discover and codify existing patterns into playbook conventions
• Stack-based matchingRails, React, Python, Go, and more — conventions auto-match to the right projects
• Auditable challenge logDeviations are logged as challenges and resolved to accept or override outcomes — with analytics on which conventions need review
• Subscribe and assignAdopt 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 behaviorCoaching, collaborative, and autonomous modes tailored to developer seniority
• Custom rolesDefine organization-specific roles with granular agent behavior modifiers
• Audit trailsEvery change is tracked automatically. Security events logged for compliance requirements.
• Convention enforcementMeasure adherence to standards across the organization with an auditable challenge log
• Privacy-first detectorsDeterministic 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 telemetryTurns, tokens, costs, tool usage, duration, and model breakdown per conversation
• Four analytics viewsSummary KPIs, timeseries trends, per-agent performance, and cost breakdown by model
• AI-powered analysisAutomatic session summaries, quality scores, coaching tips, and pattern detection
• Filter and drill downSlice 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 experimentsSplit traffic between resource versions with automatic, unbiased assignment
• Real-time metricsTrack quality scores, cost, token efficiency, and turn counts live
• Statistical significancep-values and confidence intervals ensure you deploy only proven improvements
• Automated recommendationsUpgrade, rollback, or collect more data — crewkit tells you what to do next

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 teammatesProject-scoped agents with their own Slack handle. @mention one and it answers in-thread with project context.
• Live active workSee teammates' open conversations and claimed blueprint tasks per project, in real time
• One-link session sharingShare from the dashboard or the CLI (F12+s), annotate inline, and control visibility and expiry
• Org-wide shares viewMy 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 crewkit's terminal interface can keep the blueprint visible while you code.

• Epics and tasks with dependenciesBreak work into ordered, dependency-aware units the whole team can see
• Linked to real sessionsTasks connect to the conversations that did the work, so the plan reflects what actually happened
• AI co-pilot chatPlan with an assistant that knows your blueprint's current state
• Visible from the CLIIn crewkit's interactive terminal interface, a 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 agentsrails-expert, frontend-expert, security-expert, api-designer, devops-engineer, and more
• Role-based behaviorCoaching, collaborative, and autonomous modes adapt agent output per developer seniority
• Task delegationAgents delegate subtasks to specialized agents. Every delegated task is tracked with its exact resource version.
• Context injectionProject 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 trackingEvery skill use is recorded with the exact resource and version for full traceability
• Composable with agentsSkills work alongside any agent. The agent provides domain context, the skill provides the workflow.
• Custom skillsBuild 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. Run crewkit and the native Claude Code you already know launches and owns the terminal — same interface, same shortcuts, nothing to relearn — while crewkit loads beside it: session tracking, team memory, and governance, working in the background. The CLI ships as a single fast native binary — instant startup, no runtime dependencies.

Prefer a wrapped view? crewkit tui opens crewkit's interactive terminal interface: a live sidebar with session metrics, summaries, and git context, plus a leader key system (F12 + second key) that never conflicts with the AI assistant — F12+p for the command palette, F12+i for session info, F12+d to open the dashboard for the current conversation.

Progressive onboarding means crewkit 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 setupInstall, run crewkit, and you are working. Auto-detects org and project from git.
• Your workflow, unchangedNative Claude Code owns the terminal; crewkit adds a statusline and tracks the session in the background
• Optional terminal interfacecrewkit tui adds a live sidebar and F12 leader-key shortcuts for palette, session info, sharing, and dashboard
• Progressive onboardingAuth, init, and sync happen inline on first run. Never dead-ends. Always recoverable.