This release adds personal access tokens for scripted access, brings SSO and SCIM setup into the Driver web app, and ships improvements for Claude Code.

Personal Access Tokens

Personal access tokens (PATs) authenticate to Driver’s API and MCP server as you — useful for scripts, CLI workflows, and any environment that can’t open a browser for OAuth.

• Self-service creation — Any organization member can create a PAT under Settings → Access Tokens. Tokens use the drvp_ prefix and are shown exactly once.
• Bounded expiration — Choose 30, 90, 180, or 365 days at creation. Email reminders go out as the expiration date approaches and once a token has expired.
• Administrator controls — Settings → Organization has a new Personal Access Tokens section where org admins toggle PATs on or off for the org and cap the maximum token expiration.
• Coexists with OAuth — Standard browser-based login is unchanged; PATs are an additional auth path, not a replacement.

See the new Personal Access Tokens docs for setup and configuration examples.

Settings → Machines has moved to Settings → Access Tokens as the Machines tab, so personal and machine credentials now live in one place.

Action required: Org admins must enable personal access tokens for their organization at Settings → Organization before members can create them.

Self-Service SSO & SCIM

Org admins can now configure SAML SSO and SCIM provisioning directly from Settings → SSO & SCIM — no support ticket required. Paste your IdP’s metadata URL or XML, copy the SCIM token Driver issues into your IdP, and you’re done.

See the new SSO & SCIM docs for the full setup flow.

Note: The login screen has moved to a standard two-step flow — email first, then password or SSO redirect. Some password managers may not autofill the new layout on first login; re-save your credentials if autofill doesn’t trigger.

Driver SDLC Plugin for Claude Code v1.1

The Driver SDLC plugin now takes a feature end-to-end inside Claude Code, from a new Intent capture phase that pins down goals and constraints before any research, through internal standards review (/drvr:review) and PR creation (/drvr:open-pr). The enforcement stack is also context-aware now — native search tools unlock automatically once Driver context loads — and independent tasks can run in parallel via Git worktree isolation for faster multi-task plans.

Recent UX Improvements

My Sources now has clearer status and error messages, a new favorites feature for quick access to your top sources, and a latest-commit timestamp per codebase. Bulk user and team management has also been improved across the admin views.

This release adds Content Registration, which lets you inject custom documentation into Driver’s context layer, along with MCP server updates for upcoming multi-branch support.

Content Registration

You can now register custom documentation directly into Driver’s context layer, making it available to AI agents via MCP. Useful for:

• Coding standards and style guides — Register org-wide standards — naming conventions, error handling patterns, security practices — and every agent working in any codebase will have them available automatically.
• Architecture Decision Records (ADRs) — Keep architectural rationale alongside the code. Agents can reference past decisions before proposing changes that would contradict them.
• Migration guides — During a major version upgrade or breaking change, register the migration guide so every agent working on the transition has step-by-step context — then remove it when the migration is complete.
• Legacy code guidance — Explain relationships between legacy and new APIs — for example, directing new code to a v2 API while allowing maintenance work on v1.
• Cross-codebase architecture docs — For systems that span multiple repos (microservices, frontend/backend splits), register a system-level architecture doc at the org level so agents working on any service understand the broader picture.
• Shared glossaries and domain terminology — Capture the language of your domain once and surface it to every agent — reducing the gap between how your team talks about the product and how agents interpret it.
• Onboarding guides — Register team- or subsystem-specific onboarding guides so new developers and their agents have the same orientation context from day one.
• SDLC documents — Surface requirements specs, design documents, and test plans alongside the code they describe — giving agents traceability between what was intended and what was built.

Four new MCP tools support content registration:

• register_content — register new content with Driver
• remove_registered_content — remove registered content
• get_registered_content_list — list all registered content
• fetch_registered_content — retrieve a specific registered content item

For full details, see our docs on MCP tool calls.

How to register content: Ask your coding agent or MCP-connected AI agent to register a document with Driver. In your prompt, specify:

1. Whether it applies to your entire organization or a specific codebase (and optional branch)
2. Whether it should auto-update or remain static
3. Optionally, a goal describing what the content should cover

Example: “Add the content in data_flow.md to Driver so it automatically stays updated whenever the data model or processing pipeline logic is modified. Attach this to the backend codebase.”

Set auto-update to false for content that should remain authoritative and unchanged regardless of code changes. Set it to true and Driver will revise the registered content on every relevant update to your codebase. Content can be scoped to your entire organization or to specific codebases, inheriting RBAC-based access controls.

MCP Server Updates for Multi-Branch Support

Until now, Driver tracked a single branch per codebase — the default branch. That meant any work happening off the default branch was outside Driver’s view. The further your work drifted from main, the less Driver could help you: feature branches mid-implementation, pre-merge debugging sessions, code review on an open PR, or cross-branch awareness when two teams are building in parallel.

Multi-branch support will close that gap. Once enabled for your account, Driver will track all active branches in your connected codebases, and MCP tool calls can target any of them.

Driver is enabling multi-branch support on a customer-by-customer basis. Contact Driver support via Slack, Teams, or email for timing.

What changed in the MCP tools:

• Most tools now accept an optional branch_name parameter. Omit it and Driver uses the default branch — the right fallback for agents that don’t need branch-level targeting. Pass it and you get precise, branch-specific context.
• gather_task_context has a new calling convention: the codebases parameter is now an array of objects with { codebase_name, branch_name }. This lets you pull context from multiple codebases and branches in a single call — useful when a feature spans repos or when you need to compare branches.
• A new get_branches tool lets agents enumerate the branches available for a codebase. Use it before other calls to discover what’s tracked and confirm branch names before querying.

Scenarios this unlocks:

• Feature branch implementation — Use Driver throughout implementation — not just at the start. When something unexpected surfaces mid-way through, your agent has context on the actual current state of the branch, not just where main was when you started.
• AI-assisted code review — Reviewers using AI can now ask Driver about the feature branch being reviewed — understanding what changed, what it touches, and whether architectural decisions hold up.
• Pre-merge debugging — When testing surfaces a bug before merge, Driver knows the branch under test. No more maximum delta between Driver’s knowledge and the code your agent is debugging.
• Cross-branch awareness — Pull context from a colleague’s parallel feature branch you know your work will need to interact with.
• Benchmarking — Create branches so that Driver’s MCP server will only provide context for commits on that branch. This allows for benchmark rigs that test how well AI coding agents produce code that passes tests on downstream commits. (For an example of this type of approach, see the SWE-CI paper.)

Action required: For any Claude, Cursor, Codex, or other agent sessions currently in progress, exit and restart the session. This ensures your agent picks up the updated tool schemas and descriptions from Driver.

This release adds a new usage tracking dashboard for administrators, along with continued performance and stability improvements.

Usage Tracking

A new usage tracking dashboard gives administrators and team leads detailed breakdowns of how Driver is being used across your organization.

• Total requests. See org-wide Driver activity over time.
• By user. Understand adoption and engagement across individual users.
• By codebase. See how Driver usage is distributed across your repos.
• By service. Break down activity across MCP, chat, and other Driver tools.
• Trends. Track usage patterns over time.

Performance & Stability

Continued improvements to core infrastructure for better reliability as usage grows.

We’ve shipped a number of important updates to static analysis, concurrency strategies, and cloud infrastructure to improve core performance and scaling. This release also introduces Labs and our first Labs feature, Ticket Analysis Integration.

Labs

Labs is a new opt-in feature system that lets users experiment with upcoming capabilities and early beta features directly in the Driver app. Use Labs to control which experimental features are active for your workflow. Ticket Analysis is the first feature available through Labs, with more to come.

Ticket Analysis Integration

An automatic ticket analysis system that connects Driver’s deep codebase context to your issue tracker. Connect Linear or JIRA, and Driver will analyze tickets and provide context-enriched follow-up grounded in your actual code.

Get started: Enable Ticket Analysis in Labs, then connect your Linear or JIRA instance.

Performance Improvements

A ground-up replacement of the symbol table implementation collapses processing jobs that previously ran in sequence, reducing total analysis time significantly.

Infrastructure

Continued improvements to asynchronous orchestration, cloud infrastructure, and autoscaling to provide better reliability and responsiveness. The performance and infrastructure provide important foundation for upcoming features such as multi-branch support.

Coming Soon

Multi-branch support, usage tracking, content registration, and more.

This release adds machine-level authentication for CI/CD systems, two new MCP tools, SCIM 2.0 provisioning, and real-time telemetry for codebase processing.

Machine Access for MCP

A new “Machine” identity type lets automated systems (CI/CD pipelines, scripts, bots) authenticate to the Driver MCP server independently of any user account.

• Survives employee turnover. Machine tokens are tied to your organization, not an individual. If the person who set it up leaves, your pipelines keep working.
• Fine-grained access control. Machines only see the codebases you grant them. Assign a machine to a team or grant access to specific codebases directly.
• Full admin visibility. A new “Machine Access” page in org settings lets admins see all machines, what they can access, when they were last used, and rotate or revoke keys instantly.

Get started: Org admins go to Settings → Machine Access → Create Machine.

New MCP Tools and Documentation

Two new tools and an overhaul of MCP documentation, optimized for AI agents and user onboarding.

• gather_task_context: Encapsulates an entire typical workflow using Driver’s other tools to gather context on a particular topic. This is now the preferred and primary tool. The other tools remain as primitives to be called as needed.
• get_source_file: Fetches raw source files when they are not available locally.
• Overhauled documentation: Tool descriptions and workflow documentation are now optimized for AI agents. Specific CLAUDE.md, CursorRules, or equivalent files should no longer be needed.

Action required: After updating, remove any Driver tool descriptions from your CLAUDE.md or CursorRules files. The MCP server now handles this automatically.

Real-Time Telemetry

A new telemetry status monitor displays codebase processing progress throughout the application in real time.

SCIM 2.0

Automated user and group provisioning from your identity provider. Manage Driver users, roles, and team membership directly from your directory. When users are added, removed, or reassigned, Driver stays in sync automatically.

Coming Soon

Multi-branch support, sub-agents, more integrations, and Driver solutions to common SDLC use cases.

This release makes it easier to get started with Driver and connect your AI coding tools.

Onboarding Checklist

A new guided setup sidebar helps organization admins quickly configure Driver with progress tracking for each step.

MCP Setup Page

A new dedicated page clarifies exactly how to connect Driver to your favorite AI platform (Claude Code, Cursor, VS Code Copilot, and more), including copy-paste configuration.

We’ve expanded Driver’s infrastructure to better support growing teams and larger codebases. This release focuses on processing pipeline optimizations for repositories with hundreds of thousands of files, and context generation now runs in parallel across multiple branches.

This release brings new visibility into your codebases, simplified authentication, and enterprise-ready deployment options.

Introducing Analytics

Get visibility into your repositories’ health and activity with Analytics. See commits, contributors, and code changes over time across your organization.

Organization Dashboard

See aggregate metrics across all your codebases in one view: total commits, unique contributors, active repositories, and trend lines.

Codebase Analytics

Dive deeper into individual repositories with detailed views. Track codebase size over time, yearly activity, and contributor patterns.

Branches & Contributors

Track branch health with status indicators (Default, Active, Stale) and see per-branch metrics. View contributor activity, commit frequency, and collaboration patterns.

Where to find it: Navigate to Settings → Analytics in your organization.

Single-Tenant Deployments

Private single-tenant deployments are now available for organizations requiring dedicated infrastructure.

Simplified MCP Authentication

You no longer need API keys to use Driver’s MCP tools. Authenticate directly with your Driver account for a streamlined setup experience.

We are releasing several updates focused on access control, administration, and deployment readiness.

Role-Based Access Control (RBAC)

Users, teams, and roles are now available in Driver, mirroring your internal organization and access controls. Default visibility of sources (codebases and PDFs) can be set, and granular access to specific sources can be granted to teams as well as directly to individual users.

IdP and SCM Integrations Are Next

The initial RBAC solution is designed to provide everything you need to map your access-control policies to Driver. As next steps, the team will be working on SCIM, SSO (via MS Entra ID), and direct mapping from your source-control management system.

Better Onboarding Flow and Management UX

The team is working to make initial onboarding and ongoing administration much easier. This is another area of active investment.

Streamlined Release Infrastructure

Recent release-infrastructure improvements will enable better scaling and faster updates going forward.

With richer contextual intelligence flowing into Chat, responses are more grounded and context-aware.

Driver Chat now uses the same tools provided by Driver MCP. With richer contextual intelligence flowing into Chat, responses are more grounded and context-aware.

We’ve improved language specialization for Ruby. Ruby moved onto our new language specialization mechanism, yielding improved Ruby docs: better syntax highlighting, more accurate method signatures, and deeper understanding of metaprogramming patterns.

Pagination added to select MCP tools (reliability fix). Some tools now paginate large result sets to prevent overflow edge cases when LLMs invoke them.

The team is working hard on a new RBAC implementation, multi-branch support, and private single tenant deployments.

We’ve now expanded language specialization to include Go, and we now support codebase integration with Azure DevOps.

Precision Autodocs

You can now generate autodocs for any folder or file you choose. With a single prompt, create concise, structured documentation exactly where you need it.

Deep Context Docs for Every Codebase

Foundational deep context docs are now available in the new Autodocs tab:

• Architecture Guides – detail the structure of your codebases.
• LLM Onboarding Guides – orient agents to key components, their relationships, and navigation paths.
• Development History Guides – built from commit logs to explain the evolution of your codebases.

Performance and Scalability Improvements

You should notice faster and better results across especially large, complex codebases, such as monorepos and polyglot repositories.

Now any Driver-created pull requests and merge requests will get automatically closed. This change was made based on customer feedback.

We’ve refined our automated commit messages to improve validation compatibility.

We’ve been listening to your feedback! We’re launching new ways to make it faster and easier to get value from Driver with My Sources and My Documents.

My Sources

A dedicated space for all your team’s codebases and PDFs — organized with a faster and smoother tagging and filtering system.

My Documents

Access all your team’s documents and templates in one place. View the latest activity, tag your documents, and find what you need quickly.

Also, loading time in both product spaces is now much, much faster.

Shift Your Productivity into High Gear

• Find what you need instantly with our improved tagging and filtering system
• Switch between workflows seamlessly with dedicated spaces for inputs and outputs
• Stay organized effortlessly with clearer information hierarchies and metadata
• Save valuable time with fewer clicks to access your most-used content