Skip to content
← All articles

• 6 min read

Enterprise AI autonomy levels: how far can you delegate with Argy?

Keep your current tools, move to interactive delivery, or delegate a bounded workflow. Four levels let you do more without losing control of what ships.

  • Governance
  • Software Factory
  • LLM Gateway
  • Argy Code
  • DevSecOps

When an application is already in production, the question is not whether a tool can write code. It is how much of a change you can entrust to it and still explain what shipped and why. Your team does not have to settle that question once and for all. It can answer it one scope at a time.

The scale drawn from SASE’s work starts with a simple question: Who sets the objective? The answer is different when a tool suggests the next line, when an agent is asked to make a change, and when an entire workflow is delegated. L0 and L5 mark the boundaries. Argy offers the four levels in between.

Scale from L0 to L5. Argy covers L1 through L4: govern existing assistants, connect agents, work interactively, then delegate a workflow within a configured scope.

Argy offers four levels between fully manual work and a general mandate. You set the pace.

L0 — You write everything

Your team sets the objective, writes the change, and does the work itself. This level is outside Argy’s scope. It is a useful point of comparison: at the next level, you can govern the tools that assist your engineers without delegating the change itself.

L1 — Govern the tools you already use

You write; the tool completes. If your engineers already have a way of working, you do not have to make them change it to get started. Argy’s LLM Gateway works with existing assistants such as Copilot Chat, JetBrains AI Assistant, Aider, and Cline, across development environments including VS Code, JetBrains IDEs, and Visual Studio, as well as in-house tools. You govern how those tools are used while your engineers still write the change.

L2 — Connect your agents

You describe the change. Instead of writing every line, the engineer specifies what needs to change. Advanced agents they already use, such as Claude Code, Codex, OpenCode, or Copilot CLI, go through Argy. The team no longer has to spell out the execution line by line, but it still defines the change it expects.

Together, L1 and L2 help reduce shadow AI: teams can keep using their assistants and agents under your company’s rules instead of relying on unapproved channels.

At L1 and L2, you also decide what context those tools receive: Enterprise RAG and your company’s practices are available as an opt-in, switched on through LLM Gateway settings. Teams that want an assistant grounded in your conventions get it without reinstalling anything; others keep a lighter setup.

L3 — Work with Argy interactively

You set a technical objective. The engineer describes the result they want without prescribing the exact change. This is the foundation for producing changes in interactive mode with Argy Code and Argy Workbench: the team stays involved and can focus on the outcome instead of prescribing in advance how to reach it. Even when a runner executes a ticket end to end, the work stays at L3 as long as the engineer still sets the objective.

From here on, context is no longer optional. At L3 and L4, Enterprise RAG and your company’s practices are always injected: every change draws on the available, authorized sources in the corpus you have defined (conventions, architecture decisions, documentation) rather than on a model’s generic memory.

Mythos and GPT Cyber are not available at L1 through L3. What changes across these levels is the work you hand over to the tool, not access to those models.

L4 — Delegate the workflow

You give a broad mandate within a configured scope. What separates this level from L3 is not the execution tooling but the starting question: you no longer set each objective; the factory derives the concrete objectives itself from your mandate. Tickets and Argy-managed runners, in the cloud or on your infrastructure, are simply how the work gets carried out. This level has been demonstrated on security, where the factory chains remediations within the limits you set: your standards, checks, and approval processes remain the boundary of the mandate.

Mythos and GPT Cyber are available in these managed workflows. To decide whether this level is right for you, start with the work you are ready to hand over and the rules that must still apply.

L5 — A general mandate is not on offer

At this level, you would give a general mandate rather than delegate a bounded workflow. Argy does not claim L5. L4 widens the work you can hand over, not the decisions your company needs to keep. Each level produces its own evidence: you decide whether that evidence warrants expanding the scope, and when.

Choose your first scope, not your final level

Delegation has to prove itself on applications already in production, not on an empty repository. Your code has history, dependencies, technical debt, and tests. In application maintenance, the unit of work is a delivered change. Measuring its cost gives you a basis for comparing one month to the next instead of looking only at time spent.

Evidence depends on the level, too. At L1 and L2, the LLM Gateway gives you a request trace and the policies applied, but the final change and its approval may happen outside Argy. Once Argy takes on the change, delivery comes with an audit record: what was requested, what changed, what was checked, and who approved it, depending on the level and configuration you choose. That record is assembled as the work happens. The team responsible for justifying the change has the evidence without reconstructing it after the fact.

For insurance, banking, and the public sector, vulnerability remediation is one example of a measurable starting scope: the objective is clear, and the result can be verified. Configure your rules for that scope, then use the first changes and their audit records to decide what comes next with your auditors. You do not have to start a redesign to find out what you are ready to delegate.

As the scope changes, so does your engineers’ role. As a Software Factory Engineer, then an Architect or Lead, they configure the rules, set objectives, and make the decisions the factory should not make alone. It is a way for your existing team to grow into new roles, not an extra hire. The more execution you delegate, the more their judgment matters in deciding what can be delegated.

Bring a maintenance scope to an Argy demo. We’ll identify your starting level and the evidence you want it to produce.