Today marks a pivotal moment in Gammacode's journey. We're launching features that fundamentally expand what's achievable with AI-powered coding agents working autonomously in the background.
From intelligent automations that resolve production issues before they escalate, to multi-agent support offering flexibility in your development workflow, to seamless integrations that adapt to your existing tools—this release is designed to make AI coding agents an indispensable part of your team's productivity arsenal.
Let's explore what's new and how these features can transform your development process.
Intelligent Automations: Fix Issues Before You See Them
We've built something developers have been asking for: a new automation primitive that eliminates repetitive tasks without requiring manual intervention.
The best pull requests are the ones you never had to think about creating.
Introducing Gammacode Automations—a powerful new system that enables you to automate routine development tasks through webhooks and scheduled triggers. Here's what becomes possible:
- Instant Error Resolution: Production errors from Sentry are automatically fixed within seconds of detection through webhook-driven automation. Your agents analyze the error, generate a fix, and submit a PR—all while you sleep.
- Automated Documentation: Generate weekly changelogs and release notes on a custom schedule. Never manually compile release notes again.
- Proactive Code Health: Scan your codebase for forgotten TODOs, detect security vulnerabilities, and systematically address technical debt through scheduled tasks or webhooks.
When an automation detects a task, Gammacode analyzes it within a secure sandbox environment, generates the appropriate fix, and opens a comprehensive pull request directly linked to the source problem—complete with context and explanation.
Real-World Example
A production error hits your Sentry monitoring at 2 AM. Instead of waking up to pages, Gammacode's automation receives the webhook, analyzes the stack trace, identifies the root cause, implements a fix, runs tests in a sandbox, and submits a PR for review—all before your morning coffee.
Multi-Agent Support: Choose the Right Tool for Every Task
Different development tasks demand different approaches. A simple bug fix doesn't require the same computational power as a complex architectural refactor.
That's why we're introducing multi-agent support with six distinct coding agents and flexible model selection, giving you granular control over how AI assists your team.
Available Agents
| Agent | Model Provider | Default Model |
|---|---|---|
 Claude Code | Anthropic | Claude Sonnet 4.5 |
 Codex | OpenAI | OpenAI GPT 4.5 |
 Gemini CLI | Gemini 3.5 Pro | |
 Cursor | Anysphere | Composer |
 Amp | Anthropic | Claude Opus 4.5 |
 Gammacode | DeepSeek | DeepSeek |
Flexible Configuration
- Configure your default agent organization-wide in dashboard settings
- Specify agents per-task via the API for granular control
- Set agent preferences per-integration (Linear, Jira, Slack)
- Each agent reads from its designated rule file for custom instructions
We've also enhanced the UI with searchable dropdown interfaces throughout the platform, making it effortless to select and switch between agents.
Natural Iteration with @gammacode
Code review shouldn't require context switching. We've made it incredibly simple to refine Gammacode's pull requests directly in your existing workflow.
Just leave feedback in GitHub comments and @mention @gammacode—that's it.
Gammacode processes your feedback intelligently, updates the PR with the requested changes, and keeps you informed with clear progress indicators:
- 👀 analyzing feedback - Understanding your request
- 🚀 making changes - Implementing the updates
- ✅ changes ready - PR updated for your review
💡 Pro Tip
Use GitHub's review comments or regular comments—both work perfectly. Just always tag @gammacode to ensure your feedback is processed. Clear, specific instructions like "add email regex validation to the signup form" yield the best results.
Fix commits typically arrive in 3-10 minutes, depending on complexity. It's like pair programming with an AI teammate that has deep familiarity with your entire codebase.
Linear Integration
Work seamlessly with Gammacode directly from your Linear workflow.
Simply mention or assign any Linear issue to the Gammacode agent to initiate work. Everything happens right where you already manage your tasks.
How It Works
- Assign or Mention: Assign tasks to Gammacode or mention the agent in Linear comments to get started
- Ask Follow-ups: Provide additional instructions or request modifications directly in Linear comments
- Real-Time Updates: Receive task progress updates and status changes directly within your Linear issues
MCP Support: Extend Your Agents
Gammacode agents now support the Model Context Protocol (MCP), enabling seamless integration with external systems, APIs, and data sources.
MCP empowers agents to access real-time context and tools beyond their base capabilities:
- Sub-issues - Break down complex tasks automatically
- Slack messaging - Communicate updates directly to your team
- Browser automation (Playwright) - Test UIs and automate web workflows
- Context management (Context7) - Enhanced semantic code understanding
Zero-Config Integrations
MCP servers for GitHub, Linear, and Sentry are automatically configured when you enable their integrations—no additional setup required.
Custom MCP Servers
Add your own MCP servers in Settings → Agents. Gammacode supports three server types:
- stdio - Local process-based servers
- http - HTTP-based API servers
- sse - Server-Sent Events servers
Example configuration:
{
"mcpServers": {
"my-custom-server": {
"command": "node",
"args": ["server.js"],
"env": {
"API_KEY": "your-api-key"
}
}
}
}This enables agents to query external data sources in real-time during task execution. For instance, the Playwright MCP allows agents to navigate web pages, fill forms, capture screenshots, and run automated tests—all while solving your development issues.
Transparent Billing with Auto-Replenish Credits
We've redesigned our billing system to be straightforward, predictable, and interruption-free.
Pay-As-You-Go Credits
- No subscriptions - Pay only for what you use
- Credits never expire - Use them at your own pace
- Auto-reload capability - Never run out mid-task
- Spending limits - Set monthly caps for budget control
- Real-time monitoring - Track usage from your billing dashboard
Credit Usage
Credits are consumed for:
- Pull request creation (from Linear, Jira, Slack integrations)
- Automated error fixes from monitoring tools
- Database query optimizations
- PR feedback processing and iterations
Complex architectural work consumes more credits, while simple bug fixes use less—ensuring you pay proportionally to the value delivered.
Auto-Reload Configuration
Set up auto-reload in your billing settings by configuring:
- Threshold trigger (e.g., reload when balance drops below $50)
- Top-up amount (e.g., add $200 per reload)
- Monthly spending limit for cost control
- Payment method (credit card or ACH)
Manual credit purchases are always available if you prefer more direct control.
📊 Track Your Usage
Visit app.gammacode.dev/settings/billing to configure auto-reload and monitor your credit usage in real-time.
Note: We offer unlimited usage accounts through our Enterprise plan for teams requiring predictable pricing. Schedule a meeting to learn more about Enterprise options.
What's Next
This release represents months of development and countless conversations with teams using Gammacode in production. We're excited to see how these features accelerate your development workflows.
As always, we're listening. If you have feedback or feature requests, reach out to us at hello@gammacode.dev or join our community Slack.
Ready to transform how your team ships code? Get started today.