Artificial Intelligence

    Agentic Engineering: building software with coding agents.

    Coding agents work in your repository, from internal tools to long-standing applications. Every change arrives as a pull request with tests for review.

    For development teams and product owners with their own repository who want to bring coding agents into their work, with review and tests.

    • OpenAI Codex
    • Claude Code
    • GitHub Copilot
    • GitHub Actions
    • Azure DevOps
    • Azure Boards
    • MCP
    A developer desk with two monitors and a pull request, two small robot agents write code and run tests
    01

    Monday's ticket

    On Monday the product owner describes in the ticket which extra fields the export to accounting needs, with acceptance criteria. A coding agent reads the instructions in the repository, changes the export and its tests and opens a pull request. The pipeline passes, a developer on your team reads the code, asks about an edge case and then approves the change.

    02

    How agents work with us

    Your development team and your code have carried your applications for years. Coding agents raise the pace, and the craft stays with the team: clarifying requirements, deciding architecture, reviewing code. We use agents where specification, tests and review secure the work, in our projects for you and in your own team. Codex, Claude Code and GitHub's Copilot cloud agent are part of our toolset; repository, platform and contract decide which agent fits.

    • Agents in the workflowAgents take on tickets in your developers' editor, in the terminal or in a cloud environment that starts straight from the ticket, in Azure Boards for example from the work item. Several agents work in parallel, each on its own branch, and each submits its change as a pull request.Result: agents work in the tools your team already uses.
    • Specification and instructions in the repositoryBefore the first task we record what a change has to achieve, with acceptance criteria that can be checked. The repository holds instructions for agents in AGENTS.md or CLAUDE.md: structure, build and test commands, conventions and areas an agent leaves alone; recurring routines we capture as skills.Result: every agent starts with the knowledge of your project a new colleague would get.
    • Tests, pipeline and reviewTests and CI are the safety net, and a pull request goes to review only once the pipeline is green. A person from the team that owns the code reads every change; whoever gave the task does not approve it themselves. Branch rules in GitHub or Azure DevOps enforce this technically.Result: what reaches the main branch has passed tests and a human review.
    • Security and accessAgents work in a sandbox with limited network access and credentials with minimal permissions; secrets sit in the platform's secret store and appear neither in the code nor in the history. An agent reaches tools and data through MCP servers with agreed permissions, and for each repository we set which data it may see; for tests it uses test data. We check threats such as poisoned tool descriptions or hidden instructions in code against MITRE ATLAS.Result: an agent reaches exactly what its task needs.
    • Software we build for youInternal tools, interfaces to business systems, web applications and the further development of long-standing applications, such as moving to a current .NET version with a documented API. Agents take on much of the writing; architecture and decisions stay with us and your specialists, and the documentation is written along with the code.Result: code in your repository, with tests, documentation and a history in which every change is explained.
    • Agentic Engineering in your teamWe set up your repositories for agents, train your developers on their own tickets and agree the guardrails with you: which tools are allowed, who approves pull requests from agents and what is logged. We check the licence and data terms of each tool before the start.Result: your team works with agents under rules it helped set and carries forward itself.
    03

    What the repository holds

    A repository in GitHub or Azure DevOps with a build and first tests; coverage can grow with the work. A person on the team who reviews and approves pull requests from agents. Business accounts for the chosen tools under the vendors' commercial terms, approved by IT and data protection. And the decision on which repositories and data agents may see; where a vendor processes code and prompts, we record for each tool.

    04

    Every change traceable

    Repositories with instructions for agents, tests and a pipeline that runs on every pull request. Branch rules under which agents write to their own branches and every merge needs a person's approval. A log per task: ticket, agent session, pull request, review and approval. And for your team, training on its own tickets and written rules on which tool may work with which data.

    Sound familiar? Tell us where you stand today.

    Contact

    What's new.

    As of: 11 October 2026

    • As of 11 October 2026

      Copilot cloud agent submits changes as a draft.

      Only people with write access to the repository can start GitHub's agent. It writes to its own branch with the prefix copilot/, can neither approve nor merge its pull requests, and whoever asked for it cannot approve the pull request themselves. By default, GitHub Actions workflows run only once a person with write access approves them, and its internet access is restricted.

      Source: GitHub Docs: Risks and mitigations for Copilot cloud agent
    • As of 11 October 2026

      Codex in the cloud stays off in Enterprise workspaces until IT enables it.

      According to OpenAI's admin guide, Codex Cloud is off by default for Enterprise workspaces. IT grants its use to specific groups, limits access to the repositories needed in the source system and sets environments, secrets and internet access. Requirements for local runs are distributed centrally in a requirements.toml file, and the Compliance API serves audit and investigation.

      Source: OpenAI: Codex admin rollout guide
    • As of 23 July 2026

      Azure Boards starts GitHub Copilot straight from the work item.

      From a work item, GitHub Copilot creates a branch and a draft pull request in the selected GitHub repository and links both to the work item. Copilot receives the title, description, acceptance criteria, comments and the link to the work item; the board card shows its progress. The integration requires GitHub repositories and a connection through the GitHub App, Azure Repos are not supported for it, and a run once started cannot be cancelled.

      Source: Microsoft Learn: Use GitHub Copilot with Azure Boards

    Applications we build with agents.

    An HR portal connected to Abacus at Kwaxx, currently being built, a platform for regulatory knowledge at abonax, website, portal and app with a shared API at OLAO Health, and mobile store visits for REV Ritter.

    Before the first agent opens a pull request.

    Who approves a pull request written by an agent?

    A second person from the team that owns the code, under the four-eyes principle. Branch rules enforce this technically: agents write to their own branches, and merging happens only after review and a green pipeline. For changes to permissions, payments or personal data we agree a second approval with you.

    Where are our code and prompts processed?

    With the tool's vendor, under its commercial terms; even when an agent runs locally, the model runs at the vendor. Through the Anthropic API, Claude processes globally or in the US, and for the other tools we record location and terms per contract. We do not promise processing in Switzerland for these tools. You decide before the start which repositories and data an agent may see.

    What is logged?

    For each task the ticket, the agent's session with its steps, the pull request with its pipeline run, the review and the approval. The vendors' platforms provide their own logs for administration and audit, which we connect to your existing monitoring. That way you can trace for every change who requested, reviewed and approved it.

    Do we need high test coverage for this?

    Tests catch what an agent misses, and their number can grow with the work. Where tests are missing, the agent first writes tests for today's behaviour, which your team reviews before it changes anything. That way long-standing code keeps working while it is being rebuilt.

    How does our development team learn to work with agents?

    On its own tickets in its own repository. We set up the instructions for agents with the team, work through the first tasks together and discuss the reviews. After that the team carries the rules forward and adapts them when a new tool comes along.

    Do we own the code an agent writes?

    The code sits in your repository and passes to you under the terms of our contract. The vendors' commercial terms govern the rights to inputs and outputs; we check which apply for each tool before the start, as well as the licences of the libraries an agent suggests.

    Agree on a useful next step

    Tell us about your current workflow, the systems involved and the result you need. In our first conversation, we identify what else we need to know to plan a useful next step.