Let your AI agent do the work, not just answer questions
The operating system that lets your AI agent complete any customer task, acting in your systems, under your controls.
Watch one task run from question to done
A shopper asks which EV charger will work for their car through a Quebec winter. The agent checks the catalogue, matches the connector to the vehicle, prices the option with the rebate applied, and confirms the shopper’s request to add it to the cart. Three kinds of tools, one conversation.
- The conversation
- API lookup
- Shopify MCP
- Pricing code
- The result
Answering is the easy part. Someone still has to do the work
By the time a customer reaches your AI agent, something has usually gone wrong. A flight was cancelled. A charge that doesn’t match. An order heading to the wrong door. Language models are very good at understanding a customer and deciding what to do next. When we looked at what separates a good conversation from a resolved one, the same three things got in the way.
-
Models were doing arithmetic
They were asked to parse dates, match order numbers and compute refunds. Every time they did, accuracy dropped and latency climbed.
-
Every action was a project
What an agent could do was capped by the integrations a team had time to build, so resolution stopped where the backlog started.
-
Teams wanted more control, not less
When the agent acts, which systems it may touch, and a record of every step it took.
Three kinds of tools that let your AI agent act in your systems
Each tool is something the agent can run mid-conversation: call an endpoint, run your logic, or use a tool your own server already exposes. Ada agents have always been able to call tools. Ada Computer gives them a full set, and puts every one of them on a single Tools page in the dashboard.
API tools
Get the facts before the agent speaks. Connect the APIs your business already runs, and the agent starts from the real order, the real balance, the real booking. It can read and update your records. If you’ve built with Ada, you know these as Actions.
Read the docsExample
A customer asks
Is my 6pm to Denver still on time? We’re three people.
reservations.lookup
3 passengers, 2 bags, on time
Code tools
Decide the policy the same way every time. Refund amounts, entitlements and eligibility windows come from your rules running as authored, sandboxed Python, so the number comes from your policy rather than from the model. Your team can write and test a code tool in the dashboard, or describe it to a coding agent and let it draft the Python.
Read the docsExample
A customer asks
My flight was cancelled. What am I entitled to?
entitlement.calc
Rebook at no charge, meal voucher
MCP tools
Use the tools your systems already expose. Point Ada at an MCP server your company runs, by URL, and every tool it declares is discovered. Each one starts off until you turn it on, so you keep full governance over what your agent can use.
Read the docsExample
A customer asks
Do you have the 28 inch in navy at a store near Burnaby?
inventory.lookup
1 in stock at Metrotown
Three travellers rebooked in one conversation
A return refunded in one conversation
A card protected and a dispute opened in one conversation
Fifteen locked-out teammates restored in one conversation
The Reasoning Engine™ understands the request and plans the path. A tool does the work and reports back. The engine takes it from there, so the loop is always the same: decide, act, check, decide. Switch the industry and the shape of the task stays the same.
- Reasoning Engine decides
- A tool acts
What the customer sees
Our flight was cancelled. Get all three of us to New York tonight.
Checking your booking now.
The 6:10pm via Montreal works for all three. Shall I book it?
Yes
You’re booked. Itinerary and vouchers are on your phone.
What the platform did
-
Understand the request and plan the path
The Reasoning Engine reads the message, verifies the traveller and lays out the steps before anything runs.
- Decides
Reasoning Engine
Plan: verify identity, read the booking, check what the travellers are owed, confirm, rebook.
- Decides
-
Read the reservation
An API tool pulls the record, so the agent works from what your system knows: passengers, bags, fare class.
- API tool
reservations.lookup
3 passengers, 2 bags, fare class M, disruption: controllable
- Decides
Reasoning Engine
Three travellers on one record, controllable cancellation. Check the entitlement next.
- API tool
-
Calculate what the travellers are owed
A code tool applies the airline’s own entitlement rules and returns exactly what these travellers are owed. The same inputs give the same answer every time.
- Code tool
entitlement.calc
Rebook at no charge, meal vouchers ×3
- Decides
Reasoning Engine
Present the itinerary that fits all three. An ASK step confirms with the customer before the RUN step.
- Code tool
-
Rebook, issue vouchers and close
MCP tools on the carrier’s own ticketing system do the writes. The engine reports back in plain words.
- MCP tool
ticketing.reissue
3 tickets reissued, bags retained
- MCP tool
passenger_care.issue_voucher
3 vouchers issued
- Decides
Reasoning Engine
Nothing failed. Close the task and summarize for the traveller.
- MCP tool
Illustrative scenario with sample data. Entitlements vary by airline and jurisdiction.
Read how Ada handles airline disruptionsWhat the customer sees
How much do I get back for the jacket I ordered last month, and when?
Found it: the navy jacket, delivered 19 days ago.
You’d get CA$118.40 back to your card. Want me to start the return?
Yes please
Done. CA$118.40 is on its way, usually 3 to 5 business days. Your label is in your email.
What the platform did
-
Understand the request and plan the path
The Reasoning Engine recognizes a return question with no order number and plans the lookup before it answers.
- Decides
Reasoning Engine
Plan: identify the customer, find the order, run the return policy, confirm, issue the refund.
- Decides
-
Find the order
An API tool reads recent orders from the order management system. No order number needed.
- API tool
orders.recent
1 match, delivered 19 days ago, CA$146.40, promo applied
- Decides
Reasoning Engine
Inside the return window. Run the policy on the real numbers.
- API tool
-
Calculate the refund
A code tool applies the return window, condition, promotion and shipping rules, the same way every time.
- Code tool
refund_total
Eligible, refund 118.40 CAD
- Decides
Reasoning Engine
Quote the amount and the timing. An ASK step confirms with the customer before the RUN step.
- Code tool
-
Issue the refund and close
An MCP tool on the retailer’s own server creates the return and starts the refund.
- MCP tool
returns.create
Return created, refund queued, label emailed
- Decides
Reasoning Engine
Confirmed. Close the task with the amount and the timing.
- MCP tool
Illustrative scenario with sample data. The return policy is the retailer’s own.
See Ada for ecommerceWhat the customer sees
These two payments aren’t mine. Lock my card and help me dispute them.
Thanks, you’re verified. I can see the two payments from Tuesday.
Both qualify for a dispute, with CA$173.00 in provisional credit while the bank reviews. Shall I lock the card, open the disputes and send a replacement?
Yes, please
Done. Your card is locked, both disputes are open under case 8042, and a new card ships to your address on file.
What the platform did
-
Understand the request and plan the path
The Reasoning Engine hears a fraud report and plans identity verification before any sensitive step.
- Decides
Reasoning Engine
Plan: verify the cardholder, read recent activity, check dispute eligibility, confirm, lock the card and open the case.
- Decides
-
Verify, then read recent activity
A Playbook step runs the bank’s own identity checks first. Then an API tool reads the last transactions, so the dispute starts from actual data.
- Playbook step
verify_identity
Identity and card ownership matched
- API tool
cards.transactions
Card ••1042, 2 posted payments: CA$48.00 and CA$125.00
- Decides
Reasoning Engine
Verified, two disputed items. Check the bank’s dispute rules on these amounts.
- Playbook step
-
Check eligibility and prepare the case
A code tool applies the bank’s dispute rules: reporting window, card status and provisional credit. The number comes from policy, not from the model.
- Code tool
dispute.eligibility
Within window, provisional credit CA$173.00, replacement eligible
- Decides
Reasoning Engine
Quote the credit exactly as computed. An ASK step confirms before any write.
- Code tool
-
Lock, dispute, replace and close
MCP tools on the bank’s card and disputes systems do the writes. The old card stays locked.
- MCP tool
cards.lock
Card ••1042 locked
- MCP tool
disputes.create
2 disputes opened, case 8042, provisional credit queued
- MCP tool
cards.replace
Replacement ordered to the verified address
- Decides
Reasoning Engine
All three writes confirmed. Close with the case number and what happens next.
- MCP tool
Illustrative scenario with sample data. Dispute rules and provisional credit are the bank’s own. The specialist review decides the outcome.
See Ada for financial servicesWhat the customer sees
We paid for 40 seats, but 15 teammates are still locked out.
Your payment went through. The seat update didn’t finish, so I’m sorting that out now.
15 seats need activating. I’ll retry the original update, keep everyone’s roles, and you won’t be charged again. Go ahead?
Yes, go ahead
Done. All 40 seats are active and your 15 teammates can sign in. Roles and billing are unchanged.
What the platform did
-
Understand the request and plan the path
The Reasoning Engine recognizes a billing and access mismatch and plans a reconciliation before promising a fix.
- Decides
Reasoning Engine
Plan: confirm the requester is an admin, read billing and provisioning, work out the gap, confirm, repair without a second charge.
- Decides
-
Read billing and provisioning
API tools read the paid invoice and the provisioning job, so the agent sees exactly where the update stopped.
- API tool
billing.invoice
INV8042 paid, 40 seats
- API tool
provisioning.job
PRV-8042 partial: 25 of 40 seats active
- Decides
Reasoning Engine
Paid but incomplete. Compute what should change and check the requester’s permissions.
- API tool
-
Work out exactly what to change
A code tool computes the gap and the safe retry: 15 seats, approved roles kept, no new invoice.
- Code tool
seats.reconcile
40 paid − 25 active = 15 to restore, roles unchanged, retry charge CA$0
- Decides
Reasoning Engine
Requester is a workspace admin. An ASK step confirms before the write.
- Code tool
-
Repair, verify and close
An MCP tool retries the provisioning job on your own server. An API tool checks access again before the agent says it’s done.
- MCP tool
provisioning.retry
PRV-8042 completed, 15 seats activated, original invoice reused
- API tool
access.verify
40 of 40 active, 15 checks passed
- Decides
Reasoning Engine
Verified. Close with what changed and what didn’t.
- MCP tool
Illustrative scenario with sample data. Roles, billing and access rules are the software company’s own.
See Ada for SaaS and technologyUse cases by industry
Each one is a customer request, the tool that does the work, and nothing the model has to guess. Your systems, your rules and your permissions decide what your agent can complete.
A customer asks
My bag didn’t make it. When do I get it back?
- API tool
Baggage claim status
Read the claim, the scan history and the delivery estimate the moment the traveller is verified.
- Code tool
Delay compensation
Apply the tariff by delay length, route and jurisdiction, and return the exact amount owed.
- MCP tool
Seat and itinerary changes
Change the seat or add a segment on the reservation system once the fare difference is confirmed.
A customer asks
The jacket I ordered last month, where is it?
- API tool
Order status without an order number
Read recent orders, shipments and returns from the order management system.
- Code tool
Price adjustments and promotions
Apply the price-match window and stacking rules, then quote the exact credit.
- MCP tool
Live stock near the customer
Check availability at nearby stores and reserve the item on the retailer’s own server.
A customer asks
Can I push my payment two weeks? Money’s tight this month.
- API tool
Balances and recent transactions
Read standing and history from the core banking system so a request starts from the actual data.
- Code tool
Due date changes and payment extensions
Check standing, then compute the new date and any fee exactly as your policy defines them.
- MCP tool
Profile and address updates
Update contact details in core banking after identity is verified at the step you defined.
A customer asks
Someone hit my parked car. What do I do now?
- API tool
Policy and claim status
Read coverage, deductible and open claims from the policy administration system.
- Code tool
Coverage and deductible check
Apply the policy’s rules to the loss type and return what’s covered and what the customer pays.
- MCP tool
First notice of loss
Open the claim in the claims system with the details already collected, then hand back a claim number.
A customer asks
Can we drop to 25 seats from next month without losing our data?
- API tool
Plan, seats and invoice history
Read the subscription and billing records so the agent knows the real plan and cycle.
- Code tool
Prorated credits and plan changes
Calculate the prorated credit or charge for a mid-cycle change from your pricing rules.
- MCP tool
Apply the approved plan change
Make the change in the billing system after the customer confirms, and keep the workspace intact.
A customer asks
I want a break. Can you cap my deposits at CA$200 a month?
- API tool
Account standing and recent activity
Read balance, recent deposits and any existing limits from the player account system.
- Code tool
Bonus and wagering eligibility
Apply the promotion’s terms to the account history and return a clear yes or no with the reason.
- MCP tool
Deposit limits and cooling-off periods
Set the limit or the timeout on the platform’s own tools, effective immediately and logged.
You decide when it acts and what it may touch
Giving an agent the ability to act raises the bar on governance, so we designed for it from the start.
Tools act where you put them
Playbooks place each tool call at a specific step, with the checks you want in front of it. Add an Ask step before anything that writes, and keep write tools behind a Playbook so they never run from open conversation.
Read about trust and safety-
You define when it acts
A RUN step names the tool and the moment. Check eligibility before the refund step. Verify identity before the card lock.
-
You keep judgment out of policy
Amounts, entitlements and windows run as authored code, in a sandbox, with no network access unless you allow it. The same input gives the same result in every conversation.
-
You see what ran
Every tool run is traced in the conversation view, in sequence with what the agent said and did around it. MCP runs and every enable or disable land in the audit log.
-
MCP tools begin switched off
Connecting a server switches on nothing. You enable tools one at a time, and a usage report shows calls, errors and resolution per tool.
-
Your systems’ permissions still apply
Tools run with the credentials you give them: a scoped service account, or the customer’s own sign-in on chat, SMS, WhatsApp and Instagram.
What changes for your customers and your team
-
More accurate answers
Amounts, entitlements and booking references come from your rules and your records, not from the model’s arithmetic.
-
Resolution inside the conversation
The lookup, the calculation and the write happen while the customer is still talking. No form, no callback, no second ticket.
-
New tasks without a new project
Connect an MCP server and its tools are discovered. Describe a code tool and a coding agent drafts it. Resolution no longer stops where the integration backlog starts.
The action layer of your AI agent, and it will keep growing
AI customer service started by answering questions. Now AI agents can do the work. Our direction is an agent that carries your most complex customer journeys from start to finish, across more systems, over longer stretches of work. Every task it completes also feeds the loop that makes it better: what ran, what worked, and what to coach next.
- Read
- Reason
- Act
- Check
- Complete more
Every completed task feeds the next
Frequently asked questions
It’s the name for the Tools layer of your Ada agent: API tools, code tools and MCP tools. In the dashboard and the documentation you’ll find them together under Tools, on one page that shows each tool’s type, availability, where it’s used and whether it’s active. Ada agents have always been able to call tools. What’s new is code tools and MCP tools, and API tools is the current name for what you knew as Actions. The rename, in August 2026, didn’t change how they behave.
Both. API tools support GET, POST, PUT, PATCH and DELETE, and MCP tools can create, update or cancel records through tools your server exposes. The Reasoning Engine reads the conversation, decides what to do next and chooses the tool. The tool does the work and reports back. It only calls tools you’ve made active, and Ada recommends keeping write tools behind a Playbook step so they run only inside a controlled flow.
Where the tool is defined. An API tool is defined in Ada: you describe the endpoint, the inputs and the outputs. An MCP tool is defined on a server your company runs. Ada reads the tools the server declares, you choose which ones the agent may use, and the server stays the source of truth.
It runs a small piece of Python in a sandbox: a restricted subset with a few standard modules. It only reaches domains you allow. It returns text, a number, true or false, a list or an object, and it can’t return files or images.
Code tool runs appear in the conversation view. Connecting an MCP server, enabling or disabling a tool, and each MCP tool run are recorded in the audit log, and a usage report shows call count, errors, CSAT and resolution per MCP tool. API tool calls come through the data export. Playbook step reasoning is visible in the conversation view beside each step.
No. MCP tools reuse capabilities your servers already expose: connect the server and choose which discovered tools the agent may use. API tools you configure in Ada. Code tools you author in one of three ways. In the dashboard, where the built-in test runs in the same sandbox as production. Through Ada’s MCP Server, where you describe the change in plain language and it lands on a change set that goes live only when a person promotes it. Or through the Platform API, for code that’s already reviewed in a repository or CI pipeline.
Today Ada Computer acts through API, code and MCP tools. Those reach the same systems a person would use at a computer, through the interfaces those systems expose, which is how every task on this page gets done. Our direction is more systems over longer stretches of work, and we announce capabilities when they ship.
One task your customers ask for often that your agent explains today but doesn’t finish, the systems it touches and the rules it follows. Code tools need the code tools entitlement on your agent; your Ada team can confirm what your agent is entitled to. Bring the task to us and we’ll show you what your agent needs to complete it end to end.