Consistent scrollbars across components

We introduced a unified scrollbar system (cg-scrollbar) now used across 20+ components — from Kanban boards to tables and dialogs. The result: a smoother, cohesive feel across the entire app.

Clearer calendar design

The Calendar component now highlights today’s date with improved CSS selectors for quicker visual scanning. Subtle, but meaningful for time-sensitive work.

Kanban improvements

Kanban boards are getting smarter and more manageable:

• Added tri-state checkboxes for “All columns,” so you can easily toggle column visibility.
• Added a placeholder state when no columns are shown.
• Refined visibility controls for better project navigation.

These small touches make large boards more intuitive — especially when managing multiple workflows.

Streamlined dates & cleaner code

The DateRangePicker now uses the compact MMM d, yy format (e.g., Oct 6, 25), improving readability across analytics dashboards.

Behind the scenes, unused props (popoverId, onOpenChatModal) and imports were removed across several components — another step toward a leaner, faster codebase.

Bigger uploads, better UX

We’ve removed the 100MB GitHub upload limit, letting developers handle larger assets and repositories directly through Codegen — no workarounds needed.

We also resolved card interaction bugs in Kanban, improved accessibility with focus outlines, and fixed pointer behavior in dialogs. These tweaks make the UI more predictable and a11y-friendly.

Jira issue linking

Developers can now create and manage relationships between Jira issues — like “blocks” or “relates to” — directly within Codegen. This strengthens end-to-end workflow visibility.

Voice and visual enhancements

Agents can now process Slack audio messages — MP3, WAV, AAC, FLAC, OGG — through the chat_with_video tool, enabling voice-based interactions with AI agents.

We also upgraded PR status chips in the command palette, making “Open,” “Merged,” “Closed,” and “Draft” states instantly recognizable.

Wrapping up

These releases may look small on paper but add up to a noticeably smoother, more consistent developer experience.

From unified visuals to integration depth, Codegen continues evolving as a platform that values both design polish and engineering precision.

Ready to get started? Try Codegen for free or reach out to our team for a demo.

The post Codegen Weekly Diff appeared first on The Codegen Blog.

Today we’re introducing Codegen on-prem — the same operating system for code agents that powers our cloud, packaged for your Kubernetes. Install with Helm, keep all code and telemetry inside your environment, use your model API keys, and enforce your policies.

So how does on-prem deployment work, who benefits most from it, and what makes Codegen’s approach the right fit for modern engineering teams?

What is on-premises deployment? 

On-premises deployment means the stack runs inside your own facilities or data centers, not in a vendor’s cloud. You procure the hardware and network, install and operate the software, and keep code and data within your physical and legal boundary. 

The upside is full control. You can customize the environment end-to-end, enforce your security policies, and meet strict regulatory requirements with direct access to the systems that hold your IP. The trade-off is ownership of the entire lifecycle — capacity planning, purchasing, installation, patching, upgrades, monitoring, and security all sit with your team.

Who benefits from on-prem

On-prem is a fit when code and telemetry must stay in-region or on site; when audits, industry rules, or internal policies prohibit external processing; or when the network itself is constrained (strict egress, private services, even fully air-gapped). 

In short: if “keep it in house” is non-negotiable, on-prem is the straightforward path. 

• Data residency / sovereignty: code and telemetry must remain in-region or in-house.
• Regulatory and audit pressure: finance, healthcare, public sector, or any org with rigorous approvals.
• IP sensitivity: proprietary models, unreleased features, or high-value codebases.
• Network constraints: private services, strict egress, or air-gapped environments.
• Operational integration: reuse of existing IAM, KMS/HSM, SIEM, proxies, and deployment processes.

How Codegen on-prem delivers

Codegen is an OS for code agents: it gives agents a safe runtime, orchestrates concurrent work, connects them to the tools engineers use daily, and records what happened with enough detail to trust the outcome. 

On-prem is a Kubernetes-native platform. You install with Helm charts, manage configuration in values.yaml, and use the same GitOps and CI/CD workflows you already rely on. 

Data stays put. Repositories, artifacts, logs, prompts, and agent trajectories live in your environment. If you need to route traffic through proxies or pin egress to specific destinations, you do that with your network policy and admission controls, not ours. And because model choice is yours, you bring your own API keys for the LLMs you use. 

Keys are managed locally and rotated on your schedule, with request routing that respects your security boundaries. If you prefer customer-managed keys (BYOK/CMEK) backed by your HSM or cloud KMS, that’s supported too — along with clear docs on what the keys protect and where they live.

Security posture is opinionated but transparent. Pods run under restricted policies with minimal capabilities and node isolation where practical. Policies are enforced at admission and at runtime using mechanisms you can audit (e.g., OPA/Gatekeeper for egress allowlists, trusted registries, and image provenance; RBAC for least-privilege). 

The point is simple: you control the guardrails, and the platform fits into them cleanly.

Observability is first-class. Codegen ships OpenTelemetry traces, metrics, and logs across agents, sandboxes, integrations, and check suites. We include ready-to-import “golden signal” dashboards and practical alert suggestions so SREs can see load, latency, and error profiles without reverse-engineering the system. 

Networking is explicit. We document ingress and egress patterns, DNS and proxy requirements, and the steps to run with zero outbound in air-gapped environments. If you mirror images to a private registry and provide pull secrets and pinned digests, the platform runs fully disconnected.

For more information check out our official on-prem documentation. 

What you should expect out of the box

Kubernetes-native deployment with Helm

Install, upgrade, and roll back with Helm charts. Manage values.yaml, pin images, verify signatures, and plug into GitOps and your CI/CD without special tooling.

Complete data sovereignty

Your repositories, artifacts, logs, prompts, and agent trajectories never leave your infrastructure. Enforce residency and org policies at the network and workload layers.

Your own API keys for AI models

Bring your providers and manage model API keys locally. Route traffic through your proxies, rotate on your schedule, and scope access by policy. 

Enterprise-grade support and SLAs

On-Prem is an enterprise-only offering with SLAs and hands-on help for hardening, sizing, and performance. Runbooks and escalation paths are included.

Flexible infrastructure support

Self-managed Kubernetes, OpenShift, Rancher, EKS-Anywhere — supported. Air-gapped and restricted networks are first-class: private registry mirroring, pull secrets, and offline licensing.

Getting started

Ready to see how Codegen can fit into your engineering workflow? 

Book a demo to watch it in action or contact our team to discuss deployment plans and pricing. We’ll help you explore the best path, cloud or on-prem, to bring AI agents safely into production.

The post Codegen On-Prem Deployment: Bring the OS for Code Agents In House appeared first on The Codegen Blog.

What Does It Mean to Be an OS for Code Agents?

Think about what an operating system does: it manages resources, provides isolation between processes, handles I/O, and gives applications a consistent interface to hardware. Codegen does the same for AI agents.

When you run code agents at scale, you need:

1. Process isolation: Sandboxes where agents can safely execute code without affecting production
2. Resource management: Orchestration that routes requests and manages concurrent agents
3. I/O handling: Deep integrations with your existing tools (Slack, GitHub, Linear, etc.)
4. Monitoring: Telemetry and analytics to understand what agents are doing
5. Access control: Permissions and rules to keep agents within boundaries

Codegen provides all of this as a unified platform. Your agents run on our infrastructure, but with your rules, your integrations, and complete transparency.

What’s New in Codegen 3.0

Claude Code Integration

CLI agents are the building blocks of modern AI development and Claude Code is no exception.

We’ve built tight integrations with Claude Code that bring enterprise-grade infrastructure to your terminal:

1. Cloud telemetry for every local session: Every Claude Code interaction is logged to the cloud, creating searchable history and audit trails
2. Background agents on command: Start long-running tasks without blocking your terminal
3. Full MCP access out of the box: All your Codegen integrations (Slack, Linear, databases) are automatically available through MCP

This means you can run Claude locally while getting the benefits of cloud infrastructure – monitoring, analytics, and team visibility.

State-of-the-Art AI Code Reviews

Code review has become more of a bottleneck than code production. That’s why we’re launching AI code reviews as a first-class citizen.

Our review agents:

1. Provide line-by-line analysis with actionable suggestions
2. Catch security vulnerabilities and unsafe patterns
3. Suggest architectural improvements
4. Maintain consistent code quality across human and AI contributions

Configure review rules at the organization level, then customize per repository. It’s built on the same infrastructure that powers our code generation agents, ensuring reliability and scale.

Enterprise-Grade Sandboxes

Real development means running tests, installing dependencies, and keeping massive codebases in sync.

Our sandbox infrastructure has been rebuilt from the ground up to handle this reality:

1. Instant boots: Pre-warmed environments ready in seconds
2. Persistent state: Maintain installed dependencies across agent runs
3. Production parity: Configure environments that match your stack exactly
4. Full transparency: See exactly what agents are doing in real-time

These aren’t toy environments – they’re built for codebases like Notion, ClickUp, and Linear.

Comprehensive Analytics

Any successful deployment of code agents requires measurement.

Codegen Analytics provides granular insights into:

1. Cost breakdowns: Track spending by model, agent, and team
2. Impact metrics: PRs merged, lines changed, velocity improvements
3. Adoption patterns: See who’s using what, where, and how often
4. ROI analysis: Understand the real value agents deliver to your organization

Live dashboards update in real-time, giving you the data needed to optimize your AI investment.

The Platform in Action

Here’s how it all comes together: A developer triggers an agent from Slack to implement a new feature. The agent spins up in a sandbox, pulls the latest code, implements the feature with full access to your tool stack via MCP, runs tests, and creates a PR.

When CI fails, the Check Suite Auto-fixer automatically analyzes logs and pushes fixes. The PR Review agent provides intelligent feedback. Throughout this process, everything is logged, measured, and visible in your analytics dashboard.

This is what we mean by an operating system for code agents – complete infrastructure that makes AI development work in production.

Built on Real Experience

These aren’t theoretical features. They’re built from years of experience with thousands of engineering teams shipping production code with AI. We’ve learned what breaks, what scales, and what actually matters when you’re trying to ship software, not demos.

The gap between vibe coding and professional software development is real. Codegen 3.0 bridges that gap with infrastructure built for the messy reality of software engineering.

Get Started

Codegen 3.0 is available today. Start with our GitHub integration, connect your tools, and see what it means to have real AI infrastructure. Explore all of Codegen’s capabilities in our docs.

The future of software development is here. And it’s running on Codegen.

The post Introducing Codegen 3.0: The Operating System for Code Agents appeared first on The Codegen Blog.

Tag @codegen in a Linear issue, and watch it shift from Todo to PR merged while you focus on the work that actually needs human judgment.

How it works

Codegen isn’t another bot throwing one-off code suggestions at you. It’s an agentic developer, built on Anthropic and OpenAI APIs, that understands your tickets, your codebase, and your team’s workflow.

Once connected to Linear (and optionally Slack and GitHub), you can:

• Tag @codegen in a Linear issue and watch it pick it up, plan the work, and ship the PR.
• Skip the “did this get done?” loop. Codegen updates issue statuses from Todo → In Progress → Done in real time.
• Automatically open follow-up tickets when it finds bugs, dependencies, or optimizations.
• See GitHub PRs linked directly to the Linear issues they solve.

It’s like adding a full-stack engineer to your team — one who already knows your architecture, follows your rules, and works in parallel with your human developers.

Codegen × Linear in action

Watch how Nan Yu, Head of Product at Linear, walks through how AI agents streamline task management and development inside Linear using Codegen.

The benefits you’ll notice immediately

Streamlined project management

Forget babysitting tickets. Codegen updates statuses, creates follow-up tasks, and keeps the board accurate without a PM spending half their day in “update mode.”

Code-to-task without the glue work

Every PR Codegen ships is automatically linked to its Linear issue, complete with documentation of what changed and why. No more detective work to connect code changes to business intent.

Progress without more meetings

Status updates land directly in the issue. Design decisions stay attached to the ticket. You can skip the “round-the-room” syncs that just restate what everyone could’ve read.

From ticket to PR in minutes

Whether it’s a small bug fix or a routine feature, Codegen can take it from description to merged PR, fast. It clears your backlog to frees your team for high-value engineering.

Full context awareness

Codegen understands your codebase. It implements changes that fit your patterns, follow your dependencies, and avoid regressions.

Adopting it across your team

Start small. Pilot with one team, pair early adopters with new users, and document best practices. Track your KPIs — cycle time, PR quality, backlog velocity — so you can measure the impact.

Where Codegen shines

• Routine feature tickets with clear specs
• Bugs with reproducible steps.
• Documentation updates
• Backlog grooming and estimation

What to keep in mind

• Complex architectural overhauls still need human oversight.
• UX-heavy decisions benefit from human design review.
• Vague tickets = vague output. Clear scope is king.
• Write crystal-clear issue descriptions.
• Link related tickets for context.
• Give regular feedback on Codegen’s output.
• Use a hybrid workflow: Codegen implements, humans review.
• Treat Codegen’s explanations as a training library for your team.

How to get started

1. Create your Codegen account.
2. Link it to your Linear workspace.
3. Set permissions for PR creation, rule detection, and self-assigning issues.
4. Tag @codegen in a Linear ticket and let it run.

A backlog that doesn’t collect dust, engineers freed from repetitive tasks, and a workflow where planning and delivery happen in the same breath.

The next time you open Linear and see a pile of tickets, imagine half of them already shipped before your next standup. That’s the Codegen effect.

See it for yourself — schedule a demo and watch your backlog disappear.

The post Codegen + Linear: Where Tickets Become Code appeared first on The Codegen Blog.

Understanding MCP

The Model Context Protocol (MCP) is an open standard developed by Anthropic to facilitate standardized communication between AI models and external tools.

Think of MCP as the USB-C for AI. A universal connector that allows language models to fetch information, interact with Application Programming Interface (APIs), and execute tasks beyond their built-in knowledge.

This integration gives AI agents direct access to Codegen’s APIs — letting them trigger agent runs, interact with your codebase, and seamlessly plug into your development workflow.

Bringing Codegen to your editor: Cline (VS Code)

Cline is an autonomous coding agent integrated directly into Visual Studio Code. It can create and edit files, run commands, and use the browser, all with your permission.

By integrating MCP support into Codegen, we’ve enabled Cline to interact more effectively with your development environment, enhancing its capabilities and providing a more seamless experience.

Claude, now integrated with Codegen

Claude Desktop is an agentic coding tool that operates directly in your terminal, understanding your codebase and helping you code faster through natural language commands.

With MCP support, Claude Desktop can now leverage Codegen’s functionalities more efficiently, allowing for improved code analysis and modification capabilities.

Cursor Just Got a Serious Upgrade

Cursor already lets developers chat with their code, generate functions from natural language, and edit through conversational prompts. But with MCP support and native Codegen integration, it now goes way beyond autocomplete.

It can now trigger multi-file refactors, spin up end-to-end test suites, and even run full feature implementations — all backed by Codegen’s agentic backend. It’s not just pair programming anymore — it’s orchestrated, autonomous development without leaving your editor.

Implementation Details

Our integration process focused on ensuring flexibility and ease of use:

• Flexible Transport Options: We support both stdio and HTTP transport protocols, catering to different integration needs.
• Built-in CLI Support: The MCP server functionality is now built into the Codegen CLI, eliminating the need for additional setup.
• Comprehensive Documentation: We’ve provided step-by-step setup guides for both Cline and Claude Desktop integrations, ensuring a smooth onboarding process.

Benefits for Developers

By integrating MCP support, developers can now access Codegen’s powerful code analysis and modification capabilities directly from their preferred AI coding assistants. This integration streamlines the development process, reduces context switching, and enhances productivity.

Fewer Context Switches, More Focused Flow

It’s no secret developers spend too much time on maintenance tasks like debugging, writing boilerplate, or dealing with poorly integrated tools. With MCP support, agents like Cline (VS Code) and Claude Desktop can interact directly with Codegen — reducing the need to jump between CLI, IDE, and ticketing tools just to ship small changes or triage issues.

Unified AI Stack Across Tools

MCP creates a universal protocol for tool access — so whether you’re debugging from the terminal or generating a PR from Slack, Codegen remains your backend orchestration layer. This integration helps align dev workflows across multiple surfaces, enabling consistent code quality and reproducibility no matter which assistant initiates the task.

Faster Iteration at Scale

AI agents can now manage Codegen agent runs in real time, refactor code, resolve conflicts, and even sync with your task management system. This level of automation can yield significant time savings. With Codegen + MCP, you’re not just accelerating code writing — you’re enabling agents to orchestrate multi-step, code-aware operations across the lifecycle of a feature.

Built for Enterprise Workflows

Codegen’s support for both stdio and HTTP transport protocols, built-in CLI support, and integration-level documentation ensures this isn’t a fragile or hard-to-maintain plugin. It’s a production-ready interface designed to scale with your team, whether you’re a solo developer or managing complex build systems in enterprise environments.

Getting Started

By embracing MCP, we’re not just adding another integration. Instead, we’re helping define a new era of software development where AI agents aren’t peripheral tools, but embedded collaborators. 

This is the start of a more intelligent, interactive, and deeply integrated developer stack — one where Codegen acts as the bridge between natural language intent and production-ready code. 

We’re excited to be building at the frontier of agentic software, and even more excited to see what you build when Codegen is woven into your daily tools.

For detailed instructions, refer to our MCP Integration Guide.

The post Under the Hood: How Codegen Integrated MCP for Claude, Cline, & Cursor appeared first on The Codegen Blog.

What’s Possible Today

Here are real examples of what teams are accomplishing with Codegen right now:

Development & Testing

• “Migrate me from Jest to Vitest” – Automatically update test frameworks across your entire codebase
• “Find all the TypeScript errors in our codebase, make a ticket for each one, then solve it” – Comprehensive error detection and resolution
• “Upgrade our React components to use hooks instead of class components” – Modernize legacy codebases automatically

Project Management Integration

• “Convert these Notion meeting notes to Linear tickets for follow-up, then do them” – Seamless workflow from planning to execution
• “Create a comprehensive project roadmap from our GitHub issues and update our team dashboard” – Intelligent project coordination

Documentation & Knowledge Management

• “Create me a knowledge base in Notion from my codebase” – Automatically generate comprehensive documentation
• “Generate API documentation and keep it synced with code changes” – Living documentation that never goes stale

Data & Analytics

• “Tell me about my D7 retention based on our database” – Instant insights from your data warehouse
• “Create a dashboard showing our most critical performance metrics and set up alerts” – Proactive monitoring and visualization

DevOps & Infrastructure

• “Set up CI/CD pipeline with proper testing and deployment stages” – Infrastructure as conversation
• “Audit our security practices and implement recommended fixes” – Comprehensive security improvements

Beyond Code Generation

Codegen isn’t just about writing code—it’s about orchestrating your entire development ecosystem. From GitHub and Linear to Notion and Slack, Codegen connects the dots between your tools, turning scattered workflows into seamless automation.

The future of software development isn’t about replacing developers—it’s about amplifying their capabilities. With Codegen, your team can focus on what matters most: building great products.

Ready to Ship with AI?

Experience the future of development today. Visit codegen.com to get started.

The post Ship with AI: The Future of Coding is Here appeared first on The Codegen Blog.