## Join our Team
About this opportunity
Investigate how conventional Git-based source control behaves when hundreds of autonomous AI coding agents work concurrently on a shared codebase, and compare it with alternative architectures for agent-scale development. Build an experimental environment simulating up to approximately 500 concurrent agents and evaluate scalability, merge behavior, CI impact, resource consumption and semantic integration failures.
What you will do
AI coding agents are quickly moving from assisting individual developers to working autonomously and in parallel on the same codebase. Git and the CI pipelines built around it were designed for a small number of human contributors, not hundreds of agents committing, branching and merging at machine speed. This Master Thesis investigates where that model breaks down, and which alternative architectures handle agent-scale development better.
You are encouraged to research similar solutions at other large scale software companies. You will have freedom to define areas of exploration within the project. These could include, but are not limited to:
- Building an experimental environment that simulates up to approximately 500 concurrent AI coding agents working on a shared codebase:
- o Designing realistic agent workloads and task distributions.
- o Defining a reproducible setup for running and scaling the simulations.
- o Selecting representative codebases of different sizes and levels of modularity.
- Characterizing how conventional Git-based source control behaves under agent-scale load:
- o Scalability, including repository growth, throughput and contention on shared branches.
- o Merge behavior, including conflict rates, rebase and retry loops, and queue delays.
- o Impact on CI, including build and test load, queueing and wasted compute.
- o Resource consumption, including compute, memory, storage and network usage.
- Investigating semantic integration failures, where changes merge cleanly but break behavior, and how often they occur as the number of agents grows.
- Identifying and comparing alternative architectures for agent-scale development, such as:
- o Trunk-based or merge-queue approaches.
- o Fine-grained or file/symbol-level change models.
- o Stacked changes, speculative merging or similar approaches.
- Defining metrics and a benchmarking methodology to compare the architectures fairly.
- Proposing recommendations for how source control and CI should evolve to support agentic software development.
Show the full description
The skills you bring
If you have most of the below, don’t hesitate to apply.
- Knowledge in Computer Science, Software Engineering, or a related field.
- Solid understanding of version control (especially Git) and continuous integration.
- Experience in at least one programming language (python is a plus)
- Solid understand of Linux environments and bash
- Interest in distributed systems, performance analysis and experimental evaluation.
- Eagerness to learn and explore new concepts.
- Experience with LLM-based coding agents or agent frameworks
- Experience with containerization and orchestration (e.g., Docker, Kubernetes).
