We have been building Codepylon for 18 months. Three of us, in Los Angeles. Starting today, we are opening early access to engineering teams who want to put an autonomous agent on their backlog.
I want to be direct about what this means and what it does not mean. This is not a polished product with a thousand users and a case study deck. It is a working product that we have tested extensively on our own codebase and on a small number of early access partners who gave us detailed feedback. There are rough edges. There are things that are not built yet. I will tell you exactly what both of those are.
What the idea was
In early 2024, I was working as a staff engineer at a company with a very large, very old codebase. The team had adopted an LLM-based coding assistant that year. It was genuinely useful for writing new code. It was nearly useless for working in the existing codebase, because it had no idea what the rest of the codebase looked like. Every suggestion was correct in isolation and wrong in context.
The problem was not the model's capability. It was the context. The model was working from what you could paste into a chat window. A real software problem in a large codebase requires understanding the module structure, the test coverage, the change history, the architectural conventions. That is not a context window problem. That is a repository understanding problem.
I left that job in mid-2024 to build what I thought should exist: an agent that starts by reading the whole repository, building a structural model of it, and then works from that model rather than from whatever fits in a prompt. That is Codepylon.
What is ready today
Four agent types are in early access.
Pylon-Patch handles dependency CVE remediation. It reads your scanner output, selects the minimal version bump, runs your tests, and opens a PR with a full explanation of the vulnerability and the fix. This is the most mature of the four agents. We have been running it on our own dependencies for eight months and we have high confidence in its reliability.
Pylon-Refactor handles code quality jobs: dead code removal, function extraction, module restructuring. It uses the four-stage safety check described in a separate post to verify that proposed deletions are actually safe. This agent is solid on well-typed Python and TypeScript codebases. Dynamic codebases and heavy metaprogramming reduce its confidence appropriately.
Pylon-Test generates tests targeting coverage gaps. It uses mutation testing to verify that generated tests are non-trivially exercising the code they cover. It does not generate integration tests. It targets unit-level coverage. Solid, with the caveat that tests for tightly coupled code require human review before merging.
Pylon-Migrate handles language version and framework migrations, starting with Python 2 to 3. The Python 2/3 migration support is the most developed. We will add TypeScript strict mode migration and major framework upgrades over the coming months based on what early access teams need.
GitHub support, Slack integration, and the job management UI
We support GitHub as the source of truth for repositories. Installing the Codepylon GitHub App grants us the specific permissions we need: read on repo contents, write on pull requests, read on repository metadata. We do not request write access to repository contents. The agent opens PRs via the API; it does not push directly to branches.
Slack integration is available for notifications and for job status updates. The notification format is described in a separate post. Short version: we send actionable information, not just "something happened."
The job management UI is functional but minimal. You can queue jobs, see their status, and read their logs. It is not beautiful. We prioritized making the agents correct before making the dashboard polished. The dashboard will improve over the next several months.
What is not ready
GitLab support is not ready yet. We have been asked about this more than any other feature by waitlist respondents. It is in active development and will be the first major integration we add after launch. If your team is on GitLab, sign up for the waitlist and we will notify you when it ships.
Pylon-Review, our agent for autonomous code review, is not in early access. The architecture exists and we have working prototypes, but it is not at a reliability level we are comfortable shipping. We will not ship a code review agent that gives false confidence about the quality of a diff.
Multi-repo jobs, where a single agent job needs to coordinate changes across multiple repositories, are not supported. Each job is scoped to a single repository. Cross-repo coordination requires human orchestration for now.
RBAC and team-level access control are in progress. The current model supports org-level permissions. Fine-grained team-level access control for large engineering organizations is on the roadmap for Q1 2026.
What we need from early access teams
We need feedback on where the agents fail. Not where they do the easy stuff correctly; we know they handle the straightforward cases. We need to know about the codebases and the jobs where they produce the wrong answer, stop unexpectedly, or produce a PR that looks right but is subtly wrong. Those are the cases that make the product better.
Early access is by request. Fill out the form at the link below. We will be selective about who we onboard in the first wave, not because we want to be exclusive, but because we want to maintain the bandwidth to actually support teams well and learn from what they run into.
If you have been waiting for a coding agent that starts from a real understanding of your repository rather than from what fits in a prompt window, this is what we built. We think it is a meaningfully different approach. We will find out if we are right over the next few months.