How RelayCore cut AI coding spend by 33% with Autter

RelayCore builds workflow automation software for logistics companies. Its engineers use Cursor, Claude Code, and GitHub Copilot across nine production repositories.

The tools helped RelayCore increase development output. They also created an expense that engineering leaders struggled to explain.

Provider invoices showed how much the company had spent. They did not show which repositories, agents, or engineering tasks had caused that spending.

RelayCore used Autter to connect AI usage to completed software work. Autter also recommended lower-cost models and flagged agents that consumed excess tokens or tool calls.

AI adoption created a cost attribution problem

RelayCore began with six engineers testing coding agents. Within four months, 31 engineers used them for implementation, test generation, debugging, and pull-request review.

AI spending rose from $8,600 to $31,800 per month.

The increase did not follow headcount. Some teams with similar numbers of developers showed a fourfold difference in AI spend. Two repositories accounted for 46% of the bill, but RelayCore could not explain why.

Each provider reported usage through its own dashboard. Finance could see charges by vendor and model. Engineering could inspect individual agent sessions. No shared view connected those records to a repository, task, or merged pull request.

RelayCore’s VP of Engineering needed to answer:

• Which repositories and teams consumed the budget?
• Which tasks used the most tokens and tool calls?
• Which agents repeated work or entered costly loops?
• Could smaller models complete the same tasks?
• How much had each optimization saved?
• What would the current workflow cost at three times the usage?

The team could not approve a larger AI budget without those answers.

More model power did not guarantee a better result

RelayCore had no formal model-selection policy. Engineers chose models based on familiarity, reputation, and the defaults inside each coding tool.

Developers often selected high-capability reasoning models for routine work. Test generation, documentation updates, dependency upgrades, and small implementation tasks used the same models as architecture changes and production debugging.

The company also used agents from several vendors. One agent might search the repository five times before editing a file. Another might reopen the same files throughout a run. RelayCore paid for each repeated token and tool call, but the final pull request gave reviewers no sign of that waste.

Two tasks could produce comparable results at different costs. RelayCore had no reliable way to find those cases.

RelayCore connected nine repositories to Autter

RelayCore connected its production repositories, AI coding tools, model providers, and GitHub pull requests to Autter.

Autter attributed each model call to its repository, team, agent, workflow, and task. It recorded token usage, tool calls, retries, model choice, and validation results.

Engineering leaders could start with the company’s total bill and inspect the work behind it. A high-cost repository could lead them to one workflow, then to the agent sessions responsible for the increase.

RelayCore organized its dashboard around four questions:

• How much did the completed work cost?
• Did the task pass its tests and review?
• How did its cost compare with similar tasks?
• Could a lower-cost model produce the same accepted result?

Autter grouped comparable tasks by repository, task type, change size, and validation outcome. The comparison prevented RelayCore from treating a complex migration and a documentation update as equivalent work.

A test-generation agent exposed $4,900 in annual waste

During the second week, Autter flagged a test-generation agent in RelayCore’s shipment-tracking repository.

The agent had consumed 428,000 tokens and made 73 tool calls during one run. The task cost $39.84.

The agent reopened the same four files several times. It reran an unchanged test command six times and used extended thinking for each step. The resulting tests passed, but the task cost more than the implementation it covered.

Autter found 17 comparable test-generation tasks from the same repository. Runs completed with a mid-sized coding model had a median cost of $14.73. They passed the same test suite and received the same review outcome.

RelayCore tested the recommendation across 20 tasks.

Eighteen tasks completed without escalation. Two required the larger model after the first attempt failed validation. The change reduced the workflow’s average cost by 54%.

RelayCore then updated the agent instructions to retain file context and stop rerunning unchanged commands. Those changes removed another 18% from the workflow’s token and tool-call cost.

Autter recommended changes before routing work

RelayCore kept developers in control of model selection.

Autter showed each recommendation beside the evidence behind it. Developers could inspect the comparison group, expected saving, validation criteria, and reason for the recommendation.

The team saw guidance such as:

• “This task does not require extended thinking.”
• “A smaller model completed 14 comparable tasks with the same validation outcome.”
• “This agent used 42% more tool calls than the repository median.”
• “The agent reopened files already present in its context.”
• “Use separate models for implementation and independent review.”

Developers could accept, dismiss, or test each recommendation. Autter recorded the result.

That feedback improved later recommendations. If a smaller model failed a class of migration tasks, Autter excluded those tasks from future savings estimates. If the model completed routine dependency updates without escalation, Autter added that evidence to the comparison set.

RelayCore kept high-capability models for architecture work, complex debugging, and independent review. Routine implementation and test generation moved to smaller models when completed runs supported the choice.

Results after six weeks

$31.8k → $21.4k

Monthly AI spend (−33%)

+22%

AI-assisted pull requests

$18.70 → $12.40

Median cost per merged PR

54 → 38

Tool calls per completed task

Monthly AI spend fell from $31,800 to $21,400

RelayCore cut monthly AI spending by 33%.

The team did not reduce access to coding agents. During the same period, engineers merged 22% more AI-assisted pull requests.

Cost per AI-assisted pull request fell by 34%

Median AI cost per merged pull request fell from $18.70 to $12.40.

RelayCore measured completed and merged work rather than agent sessions alone. Failed tasks and abandoned runs remained visible as waste, but they did not inflate the count of successful outcomes.

Tool calls per completed task fell by 30%

The median number of tool calls per successful task fell from 54 to 38.

Engineers revised prompts for agents that repeated searches, reopened files, or reran unchanged checks. Autter flagged new regressions when tool-call counts moved outside the workflow’s normal range.

68% of eligible tasks moved to smaller models

RelayCore moved 68% of routine implementation and test-generation tasks to lower-cost models.

Ninety-one percent completed without escalation. The remaining tasks moved to a higher-capability model after a failed check.

The savings dashboard separated evidence from estimates

Autter reported $10,400 in verified monthly savings.

Accepted model-selection recommendations accounted for $8,960. Reduced tool calls and repeated context accounted for another $1,440.

Each saving included:

• The original model and observed cost
• The replacement model and observed cost
• The completed task type
• The validation and review outcome
• The number of comparable runs
• The model prices used in the calculation

Autter excluded dismissed recommendations and failed replacement runs from verified savings. It also excluded price estimates that lacked a completed comparison task.

The dashboard displayed projections in a separate section.

At three times the current task volume, RelayCore’s old usage pattern would have cost an estimated $95,400 per month. The optimized pattern projected a cost of $64,200.

The $31,200 difference remained a forecast. Autter showed the volume assumption, current cost per task, escalation rate, and model prices beside the estimate.

Finance could inspect the calculation instead of accepting a savings claim without its assumptions.

Repository-level costs changed planning conversations

Before Autter, RelayCore assigned AI spending to a central engineering budget. Product teams had no view of the costs their work created.

Autter showed cost per repository and workflow.

The shipment-tracking team spent more on test generation. The integrations team spent more on debugging because its agents called external tools. The platform team used expensive models less often, but its architecture tasks had the highest cost per run.

Engineering leaders could judge each expense against the work involved. They stopped comparing teams through total token counts alone.

The repository view also helped RelayCore forecast new projects. A team planning a large integration could use observed costs from comparable work instead of applying a company-wide average.

Engineers began selecting models by task

RelayCore added model guidance to its engineering playbook.

Developers now start routine implementation with the lowest-cost model that has completed comparable work. Failed validation triggers escalation. Architecture decisions and independent review use separate models when the risk warrants the additional cost.

Autter monitors the results and updates the evidence behind each recommendation.

The policy gives RelayCore a path to control AI spending as usage grows. Engineers retain access to capable models. Finance receives forecasts tied to observed work. Product leaders can see how AI costs change as a feature moves from experiment to production.

RelayCore’s stack

AI coding costs become harder to govern as more developers and agents enter the software lifecycle. Autter connects that spending to the engineering work that produced it and gives teams evidence for reducing it.

Autter helps enterprises govern and reduce the cost of AI-generated software.