AI Agents

AI agents that own a job end to end — invoicing, compliance checks, recurring reporting — and only come back to you for the exceptions.

What an AI agent is, in plain terms

An AI agent is software that owns a defined operational job from start to finish: it runs on its own schedule, applies your rules to your data, does the work, records what it did and why, and escalates only the cases a person needs to judge. CodeFish Studio builds these in Adelaide for Australian operations teams inside an Apex partnership. The difference from a chatbot or a copilot is who starts the work. A copilot waits to be asked and gives an answer. An agent does not wait, and the task leaves someone's list rather than getting faster. The test for whether a job suits an agent is not how clever it is. It is whether the rules can be written down and the outcome counted. If both are true, an agent can own it.

What jobs can an AI agent own?

Invoicing and billing

Generate, match, and reconcile invoices against your rules, then flag only the exceptions a person needs to see. The month-end grind, handled continuously instead of in a scramble.

Compliance checks

Run every case against your policy and regulatory rules, record the decision and its reasoning, and escalate the edge cases. An audit trail by default, not an afterthought.

Forecasting and analysis

Turn your operational data into rolling forecasts and early warnings, updated as the numbers move rather than once a month when someone finds the time.

Recurring reporting

Assemble the reports your team rebuilds by hand every week, drawn straight from the connected data layer so the figures are current and consistent every time.

Hands holding a 3D-printed green and grey prototype part over engineering sketches

One agent, one job, done properly

General-purpose assistants impress in a demo and disappoint in production, because a business does not need a clever chatbot. It needs a specific job done reliably, every time, to the same rules a good employee would follow. So we build narrow. Each agent is scoped to a single operational job, given your rules, and connected to your data through one source of truth. It runs quietly in the background, does the work, and hands anything outside its boundaries back to a person. Up to three agents per deployment, each earning its place. Agents are one part of our wider AI application development work.

How do we build an agent?

Define the job

We pick one recurring operational task and define it precisely: the inputs, the rules, the outputs, and the edge cases that come back to a person. A tightly scoped job is an agent that works.

CodeFish Studio team members in a workshop

Build and bind it

We build the agent to those rules and connect it to your data through a single source of truth. It runs against real cases in a controlled way before it touches anything live, so you see how it behaves before you rely on it.

A CodeFish developer working across three monitors, reviewing code and version history

Deploy and measure

The agent goes live tied to an outcome: hours returned, errors cut, throughput lifted. We measure it against that number and tune it. If it is not delivering, we change it or pull it.

A hand on a laptop showing a colour-coded project Gantt schedule, with the same view on a wall screen

Rules first. An agent earns its place only where the work needs judgement a rule cannot give.

An agent, an automation, or a person?

Most real deployments are all three. The value comes from putting each in the right place rather than choosing one.

Rules for fixed steps

If the task follows steps you can write down, rule-based automation does it more cheaply and predictably than an agent.

An agent for judgement

An agent earns its place where work needs reading and deciding, such as an email that could be one of six requests.

A person for the consequential

A person keeps the parts where being wrong is expensive or irreversible, and the escalation rate is watched as a health measure.

What does an agent cost?

It starts with a Rapid Insight Workshop at a fixed $9,000 + GST, which finds where the judgement work sits and which of it is ready to hand over. The build is rarely the expensive part: the effort goes into data access, evaluation and limits on what the agent may act on.

Running costs are ongoing: usage, monitoring and review time. A first agent runs fixed-price as an Amplify project; agents across several processes run as an Apex partnership.

What has to be true before an agent runs

None of these are about the model. They are the conditions that decide whether an agent is safe to let near real work.

A job with an edge to it

A defined task with a start, a finish and a definition of done. An agent given a vague remit produces vague work, and nobody can tell whether it went well.

Written-down rules

The decisions a person makes doing this job, stated explicitly. Where the rules live only in someone's head, writing them down is the project — and it usually improves the process before any software exists.

Scoped access

What it may read, what it may change, and what it must never touch. Permissions that match the job, not the convenience of whoever set it up.

An escalation path

A queue for the cases it should not decide, with the context a person needs to decide quickly. An agent that never escalates is not careful, it is overconfident.

A record of what it did

Every action logged in a form someone can audit. When a customer asks why something happened, the answer cannot be that the system decided.

Someone checking the output

Sampled and compared against what a good result looks like, the same way you would review a new starter. Quality drifts quietly otherwise, and the drift is only visible if you are looking.

AI agent questions we get asked

An AI agent is software that owns a defined operational job end to end. It runs on its own rather than waiting to be prompted, applies your rules to your data, logs every decision and its reasoning, and hands the exceptions back to a person. In practice that means invoicing and reconciliation, compliance checks, forecasting, or the reports someone rebuilds by hand every week.

A copilot waits for a person to prompt it and gives an answer. An agent owns a job: it runs on its own against your rules and your data, does the work end to end, and only comes back to a person for the exceptions. The difference is a clever assistant versus a reliable one that actually removes the task from someone's plate.

Narrow, rule-based, recurring operational work: invoicing and reconciliation, compliance checks, forecasting, and the reports your team rebuilds every week. The test is not how clever the task is, it is whether the rules can be written down and the outcome measured. If they can, an agent can own it.

Yes, and that is the part most projects skip. An agent acts on data and follows rules, so if the data is fragmented or the rules live in people's heads, we fix that first — usually by connecting your systems into one source of truth the agent can act on. No foundation, no reliable agent.

Every agent is scoped to a defined job with explicit boundaries. It logs what it did and why, runs against real cases in a controlled way before it touches anything live, and hands anything outside its remit back to a person. You can see what it does, why it did it, and where it stops. No black box.

Anywhere the cost of a wrong action is higher than the cost of a person doing it. Irreversible decisions, anything with a legal or safety consequence, and any process nobody has written down yet. If the rules only exist in someone's head, the first job is writing them down, not automating them.

The same way you would judge a person doing the job: sample the output, compare against what a good result looks like, and watch the rate of escalations. An agent that never escalates is usually not being careful — it is being confident, which is a different thing.

Model usage is small at business volumes. The ongoing costs that matter are monitoring, the review time to keep quality honest, and the changes needed as your process moves. Budget for those from the start — an agent nobody reviews degrades quietly, and that failure is harder to spot than an outage.

Most businesses start with one, on the job that hurts most. A deployment inside an Apex partnership runs up to three agents, each scoped to a single job and each earning its place. We would rather deploy one agent that works than five that half-work.

AI agents are delivered inside an Apex partnership, sitting on a connected data foundation. Pricing is scoped to the jobs being automated and the value they return in hours and cost. We define that up front in a short discovery step, so you see the number and the expected return before any build begins. The usual entry point is a Rapid Insight Workshop at a fixed $9,000 + GST, which maps the candidate jobs and what each is worth.

A first agent on a single well-scoped job typically reaches production in six to twelve weeks. Where the data foundation has to be built first, add to that — connecting the systems is usually the longer half of the work, not the agent itself. Anyone quoting a production agent in a fortnight is describing a demo.

Ask for an agent that is still running twelve months later and the number it moved. Ask what happens when it gets something wrong: who sees the exception, and where the decision is logged. Ask whether they will tell you not to build. And check the ownership terms — you should own the code, the data, and the IP, not rent them.

What do we build agents with?

  • OpenAI

  • Anthropic Claude

  • LangChain

  • Python

  • Vector databases

  • REST APIs

  • Webhooks

  • PostgreSQL

  • AWS