AI agents are becoming active contributors in software engineering teams, handling ticket triage, code implementation, pull requests, and standups alongside human developers. This article breaks down how one multi-team organization built that workflow using Linear, GitHub, Cursor, and Claude-powered agents, and what 18 months of doing it for real actually taught them.
Most conversations about AI in software development still live in the realm of demos and “what if.” On one long-running engagement, a B2B platform for a US-based enterprise client with a strong appetite for new technology and an explicit goal of becoming “AI-first” our developers have spent the better part of the last year and a half living the reality.
Not a pilot, not a sandbox: AI woven directly into how a multi-team engineering organization ships code every day.
This article summarizes what Levi9 Software Engineers shared in a recent TuesdAI session, what the workflow actually looks like, which tools earn their place, and what they’d tell anyone heading down the same road.
A toolchain built around the ticket
The center of gravity isn’t an AI model, it’s the work item. The team runs project management in Linear, chosen for the speed and flexibility that suit a fast-moving, microservices-heavy product (the platform began life as a monolith and has since been broken into services). What makes it powerful here isn’t the board itself, but how tightly it’s wired into everything else:
- GitHub links commits and pull requests directly to their tickets, so context never gets lost.
- Slack lets the team triage, comment, and get notified on tickets without leaving the conversation.
- AI tools plug in at the same layer, so an agent can pick up a ticket, act on it, and report back through the same channels a human would.
For hands-on work, developers lean on Cursor, where they keep tight, step-by-step control. For autonomous work, the team runs AI agents powered by Claude models. That distinction, hands-on control versus delegated autonomy, turns out to be the whole game.
Agents as teammates, not tools
The most striking part of the setup: the agents are treated as legitimate members of the team. Each runs as its own instance on cloud infrastructure, with its own persona, and its own accounts on GitHub, Linear, and the team’s chat platform. With roughly seven teams on the project, each team has a specialized agent scoped to the microservice and domain it owns.
Each agent operates through a set of well-defined “skills” that together mirror a developer’s own workflow:
- Triage: check that an incoming ticket is well-formed, has the information it needs, and belongs to the right team and project.
- Planning: pull the ticket, clone the relevant repository, analyze the code, and write an implementation plan back into the ticket.
- Investigation: for bugs, analyze the most likely root cause.
- Implementation: create a branch, write the code, commit, and open a pull request with a filled-out description, then move the ticket to review.
- Report back: post a summary of what was done to the team’s daily channel, where agents and humans share one standup feed.
Pull requests get reviewed, too, an agent assigned to the relevant repository reads the change and leaves genuine, often legitimate, feedback. The original vision was ambitious: agents working through the night to produce dozens of pull requests, with human engineers building on top of them by day.
The agents aren’t a feature bolted onto the workflow. They have their own accounts, their own scope, and a seat in the standup channel, they show up like any other engineer.
The guardrails are the hard part
Autonomy without limits is a liability, so the boundaries are codified – literally, in configuration files that define what each agent may and may not do for every action. The principles are consistent:
- No destructive actions. Agents don’t get to break things irreversibly.
- No production deployments without a human. Bigger decisions escalate to a person.
- Scoped permissions per role, defined explicitly rather than assumed.
This is the quiet, unglamorous work that separates a viable AI workflow from a risky one — and it’s where much of the real engineering effort goes.
Beyond code: support and expert agents
The agentic approach extends past the codebase. The team runs an internal support agent that helps employees resolve IT and support requests faster, searching internal documentation, answering questions, and handling routine tasks like access requests, with permissions tightly defined for what it can and can’t touch.
On top of that sit expert agents, each specialized for a particular domain and equipped with its own memory, delivering faster and more precise answers than a single general-purpose assistant could.
There’s also a compelling operations angle: when a production incident hits, an agent integrated across the team’s systems can be pointed at a time window and asked to investigate, and it can often surface the actual culprit, down to something as specific as a missing database index slowing the whole system.
What Works, What Doesn't, and What It Costs
The real value comes less from the tooling and more from the perspective gained by using it in real work, in an environment everyone agrees is still early, messy, and unsettled. A few things stand out:
- The middle path wins. Fully autonomous, overnight agent work is great for simple, well-scoped tickets. For anything complex, engineers stay in the driver’s seat with tools like Cursor, guiding the work step by step. The sweet spot is a blend, not a replacement.
- Ownership stays human. The agent can draft, implement, and review, but responsibility for what ships still belongs to the individual engineer. A person reviews, approves, and answers for the result. That accountability doesn’t transfer.
- More tools isn’t the goal, the right tools are. After an initial phase of “give everyone access to everything,” the team has been deliberately consolidating around what proves efficient. Heavy, effective usage tends to concentrate in a smaller group than you’d expect.
- Cost and ROI deserve real attention. Agent runs aren’t free, and usage-based costs can climb quickly. Measuring the return, not just the spend, is an open and important question.
- Security and discipline scale with autonomy. The more an agent can do, the more rigor the surrounding process needs.
Common Questions, Straight Answers
What tools do AI agents use in a software development workflow?
The core stack in this setup: Linear for project management, GitHub for version control, Slack for communication, Cursor for hands-on AI-assisted coding, and Claude-powered agents for autonomous tasks. The key is tight integration — agents operate through the same channels and accounts as human team members.
What tasks can AI agents handle in software development?
In this workflow, agents handle ticket triage, implementation planning, bug investigation, branch creation, code writing, pull request submission, and daily standup reporting. Each task is a discrete “skill” the agent is explicitly configured to perform, not open-ended autonomy.
What is the difference between AI-assisted and fully autonomous development?
AI-assisted development keeps a human in the loop at every meaningful step — the developer uses tools like Cursor to guide work interactively. Fully autonomous development delegates an entire task to an agent with minimal human input. The most effective teams use both: autonomous agents for simple, well-scoped tickets; human-guided tools for anything complex.
What guardrails should AI agents have in a development workflow?
At minimum: no destructive or irreversible actions, no production deployments without human sign-off, and scoped permissions per role defined explicitly in configuration. The guardrail design is unglamorous work, but it’s where most of the real engineering effort in an agentic setup goes.
Who is responsible when an AI agent ships code?
The human engineer who reviews and approves the pull request. Agents can draft, implement, and leave review comments — but accountability for what ships doesn’t transfer. A person signs off, and a person answers for the result.
The Direction Is Clear
AI-assisted development, done seriously, isn’t about replacing engineers, it’s about redesigning the workflow so that humans and agents each do what they’re best at. The teams getting real value aren’t the ones chasing the flashiest demo; they’re the ones investing in integration, guardrails, and clear ownership, and staying honest about what works and what doesn’t.
We’re still in the experimental phase. But the direction is clear: the ticket-to-pull-request pipeline now has new contributors on it, and learning to work alongside them well is fast becoming a core engineering skill.
***This article is part of the AI9 series, where we walk the talk on AI innovation.***
In this article:
Igor Nikolić, Software Engineer
Miroslav Galić, Software Engineer Levi9 Serbia
Levi9 Serbia
