VantaSoft Agent Service
AI Software Engineer.
An AI software engineer is an agent that works the tickets in your codebase. It traces bugs to their cause, makes each change on its own branch, runs your tests and opens a pull request for review. Merging, releases, access and architecture stay with your engineers.
Markus
Engineering
Purpose
Take routine technical work off your engineers' plates. Markus builds and maintains approved integrations and internal tools, and every change goes through your normal code review.
Reports to
CTO, engineering lead, or the person who owns your technical systems.
Core outcome
Integrations, internal tools, and routine technical work get done and documented through your normal review process, and your engineers stay on the work that needs them.
The work Markus takes on.
- Build and maintain integrations between the systems you approve.
- Build and update internal tools, scripts, and automations.
- Work tickets from your backlog and open pull requests for review.
- Investigate bugs and failed jobs and report the cause with a proposed fix.
- Write and update tests for the code he changes.
- Keep dependencies current and flag security advisories that affect your code.
- Document changes, setup steps, and how each integration works.
- Flag technical risks and recurring failures to your engineering lead.
The gates between a ticket and your main branch.
Every change passes these checks in order, and a failure at any of them sends the work back a step.
- Its own working copy
- Each ticket gets a separate checkout of the repository on a new branch, so half-finished work never mixes with another change or touches your main copy.
- His own read of the diff
- Before a pull request opens, he reads the whole change for mistakes and for code that could be simpler, however small the change.
- Your tests and build
- The checks your repository already runs, plus a new test for the bug he fixed. A failing check stops the work here.
- Your code review
- The pull request goes to your usual reviewers. Comments from automated review tools get the same answer as a person's: a fix or a reason.
- Independent testing
- When you want a tester's sign-off, your tester, human or agent, reproduces the original problem and re-checks the fix. Anything they find goes back to Markus on the same ticket.
- Merge and release
- Your engineer merges the change and decides when it ships. Markus then checks that it works in use.
What his pull requests spell out.
A reviewer shouldn't have to piece the work back together from the diff. Each pull request answers these up front.
- The ticket
- Linked, so the original request and its discussion sit next to the code.
- What was wrong
- The cause, with the log line, error or failing case that showed it.
- What changed
- The change in plain words, and anything nearby he chose to leave alone.
- How it was tested
- Each check he ran and its result, the new test included.
- What to watch
- The job, page or number that will show the fix is working once it ships.
What Markus never does.
These lines hold from his first ticket.
- Push to your main branch
- Every change, one-line fixes included, reaches it through a pull request.
- Approve his own work
- Someone else reviews every pull request he opens. At the start, that is always one of your engineers.
- Call an unrun check a pass
- If a test can't run, for instance because a service it needs is down, the pull request says so and lists what is still unverified.
- Take a ticket someone else holds
- Each ticket has one owner at a time. Before touching files that another open pull request changes, he checks with its author.
- Leave a secret where people can read it
- Passwords and keys stay in his own locked storage, never in code, a ticket, a log or a chat message.
One ticket, from intake to merge.
Say the nightly job that copies new web-form leads into your CRM failed, and your engineering lead filed a ticket. This is its path to a merged fix, inside the access you approved.
- His next check of the board turns up the ticket. He assigns it to himself so nobody else starts on it, and says in your engineering channel that he has it.
- The job's logs show the cause. The form tool renamed a field last week, so the job no longer finds the phone number it expects.
- In a fresh working copy on a new branch, he points the job at the new field name and writes a test that fails on the old name and passes on the new one.
- He runs your test suite and the build. Both pass, so he opens a pull request linked to the ticket with the cause, the change, the test results and the run to watch after release.
- Your reviewer asks for a warning in the log whenever the old field name turns up again. He adds it in a follow-up commit and replies under the comment.
- Your engineer approves the pull request, merges it and decides when it ships.
- After the release he watches the next nightly run finish, notes the renamed field in the integration's documentation and closes the ticket.
How a working day runs.
- Start of day
- Read overnight job failures, alerts and new tickets, and post the ones that need a person first.
- Through the day
- Check the board on a set interval, take the next ticket assigned to him and stay on it until its pull request is open.
- Review comments
- Answer every comment on his pull requests, with a follow-up commit or a reason for leaving the code as it is.
- After a merge
- Watch the change in use, then update the documentation and close the ticket.
- End of day
- Post what merged, what is waiting on review and what is blocked, with the reason for each block.
Where his access stops.
What Markus can do
Markus can write code, open pull requests, run tests, and update tickets and documentation in the repositories and tools you approve.
What stays with your people
Merging, production releases, access and credential changes, security decisions, and architecture choices stay with your engineers.
Calls he hands back to you.
- Access and credentials
- New logins, wider permissions and keys, his own included, are granted by the person who owns that system.
- Security findings
- An advisory that affects your code goes to your engineering lead with what it touches. How to respond is their call.
- Architecture
- A new service, a new database or replacing a tool. He can lay out the options and the tradeoffs, and your team chooses.
- Anything that cannot be undone
- Deleting records in a live system stays with a person at launch. Our discovery sessions start from that default.
What your engineers notice.
Your engineers no longer begin the day in failed-job logs. When something breaks, they get a pull request with the cause already written up.
Documentation keeps up with the code, because updating it is part of closing a ticket rather than a chore for later.
Your review process stays as it is. Markus works through the same branches, tests and pull requests as everyone else, so the checks you already trust cover his work too.
How we run this at VantaSoft.
Our own engineering agent is also called Markus. He builds and maintains our website, our content system and our internal tools, and he checks his list of engineering tickets every 30 minutes. A second engineering agent works on our voice product, and a testing agent re-tests fixes on the tickets assigned to her and recommends go or no-go.
One lesson from running agents on our own systems is that a rule that must always hold belongs in the tooling rather than in an agent's instructions, because instructions get interpreted. When one of our publishing jobs pushed other people's held-back changes live along with its own article, we moved the rule into the publishing tool. It now refuses to go ahead unless every change is an article.
We kept one step manual on purpose. None of our agents decides alone that its own work is ready for independent testing. A person makes that call, because an agent judging its own work ready to be checked is grading itself.
How to judge his work.
- Tickets closed and accepted in review
- Pull requests merged without a second round of rework
- Failed jobs fixed at the cause rather than rerun
- Integrations and tools running without manual fixes
- Documentation updated in the same ticket as the code
- Engineer hours still going to routine tickets
Where to start him.
Start Markus on one repository and one kind of ticket, such as failed integration jobs. Add the next repository once his pull requests there stop coming back for rework.
We build Markus around your repositories and your review process, coach your engineers on handing him work, and keep him running.
Read next
- AI Agent Integration: Which of Your Systems Are Ready to Connect Six checks that show whether a system is ready for an agent to connect to it.
- What Went Wrong When We Gave AI Agents Real Work Five dated failures from our own agents, what each one cost, and the check that catches it now.
Related roles
- AI Quality Assurance Agent Leila records each issue with the steps to reproduce it and re-checks a fix before the issue is closed.
- AI Project Manager Kenji keeps the board around the code current, so every ticket has an owner and a due date.
Put Markus on your backlog.
It starts with 30 minutes on how your company runs.
Updated