Building AI Agents for Business: A Cross-Discipline Guide
Updated: 3 days ago

UIT, UIB Cross-institute lecture
Series Cross-Institute Series
Duration 25 minutes
Delivering institutes: UIT (Institute of Technology); UIB (Institute of Business)

UNOP Sound (University 365 Neuroscience Oriented Pedagogy)
Take five minutes to prepare your brain. Play the isochronous tone track (40Hz gamma frequency) with your eyes closed. Gamma-frequency tones before a learning session raise attention and make the material easier to absorb.
[Audio player: UNOP Pre-Lecture Isochrone (40Hz, 5 minutes)]
In this Lecture
The Hook: The Automation That Answered the Wrong Question
A company builds its first AI agent in a week. The engineering works. The agent reads incoming customer emails, classifies them, and drafts replies. The demo is impressive. Six weeks later, the team quietly switches it off.
What happened is not a technology failure. The agent classified email types that the support team had already stopped using. It drafted replies with a tone the brand team rejected on sight. It escalated urgent messages to a queue nobody monitored. Every one of those defects was a business fact that the engineering team was never given, and every one of them was knowable in advance.
Now a second company, same size, same tools. Before writing any code, its product manager and its lead engineer spent one afternoon on three questions: which process actually costs the most time, what the reply must say to be acceptable to the brand team, and where a human must decide. They wrote the answers down. The agent they built handles less than the first company's did. It has been running for a year.
This lecture is the guide for that afternoon. It is written for two audiences at once: the technical reader who will build the system, and the business reader who will own the outcome. Each has half the information the project needs.
Step 1: Find a Process Worth Automating
The first mistake in agent projects is choosing the demo. The right first process has four properties.
It is high volume. A task done ten times a day does not repay the build and maintenance cost. A task done two hundred times a day, or one that blocks a queue when it is slow, does.
It is structured enough to describe. You can write the steps down and they hold most of the time. The exceptions matter, but the spine is stable.
Errors are survivable and detectable. A draft that a human reviews before sending is a good first target. An irreversible action that a human never sees is a bad one.
The volume sits in the middle, not at the ends. Work that is pure routine is often cheaper to script without AI. Work that needs senior judgment at every step does not suit an agent yet. The sweet spot is work that is repetitive in shape and varied in content: classification, drafting, extraction, summarisation, routing, first-line response.
The business half of this step is the process map: the actual volume, the actual cycle time, the actual cost of a mistake, and the person who owns the outcome. The technical half is the feasibility read: is the input machine-readable, are the systems reachable, is there an API or only a user interface.
Neither half can rank the candidates alone. A process the business considers trivial becomes important when it is the bottleneck; a process the engineers find elegant becomes irrelevant when its mistake cost is a customer.

Step 2: Draw the System Before You Build It
Before any model call, draw three things on one page.
The workflow. The sequence of steps the process actually follows today, including the queues and the handoffs. Not the idealised version in the procedure document: the real one, with the workarounds people built.
The data flows. What enters, from where, in what shape, and what leaves. Mark every system the process touches. This is where the integration cost lives, and it is usually the largest line.
The decision points. Every place where a human currently makes a judgment call. Each one is a candidate for one of three treatments: automate it (the rule is clear), assist it (the agent drafts and a human approves), or keep it human (the call carries accountability or relationship weight).
The page becomes the contract between the two halves of the team. When engineering says "we built what you asked for" and the business says "this is not what we meant", the page shows which reading was written down.
A rule from the U365 lectures on this topic: an agent is software that takes actions, not a chatbot that talks. The drawing stage is what separates the two. A conversation has no queues, no data contracts and no failure modes; a system does.
Step 3: Choose the Agent Pattern That Fits the Job
Not every job needs a multi-agent architecture, and reaching for one too early is a common and expensive mistake. There are four patterns, and they escalate in cost.
Pattern 1: A single call with tools. One model, one step, a defined set of functions it may call. Good for classification, routing, extraction and structured lookup. If this pattern solves the problem, use it: it is the cheapest to build, the cheapest to run, and the easiest to debug.
Pattern 2: A single agent with a loop. The model observes, decides, calls a tool, observes the result, and repeats until the task is done or a step limit is reached. Good for multi-step tasks inside one domain, such as gathering information from three systems and assembling a report.
Pattern 3: A pipeline of specialised agents. Each agent owns one stage and passes a structured result to the next: intake, validation, drafting, review. Good when the stages have genuinely different inputs and different quality bars. Each stage can be tested on its own.
Pattern 4: Coordinated agents with a planner. A lead agent decomposes the task and delegates to specialists. This is the most capable and the most fragile pattern: failures compound, costs multiply, and debugging requires tracing a conversation between machines. Use it only when a real task has proven it needs it.
The business half of this decision is the exception profile: how often the process deviates, and what a deviation costs. The technical half is the reliability requirement: how many steps can fail before the outcome is unusable.
Choose the simplest pattern that meets the requirement, and write down why the next pattern up was rejected. That note is what prevents an architecture from growing for prestige.

Step 4: Give the Agent Its Tools, Carefully
An agent's capability is the set of actions it can take, and that set is the project's largest risk surface. Four rules keep it manageable.
Least privilege. Give the agent the narrowest tools that do the job. A tool that can read an order is not a tool that can refund it. Where a system offers both a read and a write interface, wire only the read interface until the read path has proven itself.
Confirm irreversible actions. Payment, deletion, public posting, email to a customer: any action that cannot be undone goes behind a human confirmation, an approval queue, or a dry-run mode for the first period of live operation.
Describe the tools for the model, not for the developer. The description is what the model reads when it decides whether to call the tool. Write it the way you would brief a new colleague: what it does, when to use it, what it returns, and what it must not be used for. Vague descriptions produce wrong calls, and wrong calls are the most common visible failure in production agents.
Log every call. Which tool, at what time, with what arguments, with what result, on whose behalf. This log is how the system is debugged, audited, and improved, and it is the first thing a serious incident review will ask for.
The business half of this step is the authority map: who is allowed to approve what, and under which conditions. The technical half is the interface inventory and the failure behaviour of each dependency: what the agent should do when a system is down at 2 a.m.
Step 5: Put People at the Points That Matter
Human-in-the-loop is not a compromise or a transition phase. It is a design decision, and the useful question is not whether to include humans but exactly where.
Review points sit before an irreversible or reputation-bearing action: a send, a publish, a payment, a commitment. The human sees the draft and the evidence, and approves, edits, or rejects.
Escalation points sit where the agent's confidence or the case's stakes exceed a threshold: an unusual request, an angry customer, a value above a limit, a situation the classification does not cover. The escalation must lead somewhere monitored, or it is theatre.
Sampling points apply after the system is trusted: a periodic human review of a sample of live outputs, checking quality the day-to-day flow would never surface. Sample review is how quality drift is caught early.
Design the handoff as carefully as the automation. What does the human see: the draft alone, or the draft with its sources and its uncertainty? How long does a review take? What happens to a rejected item: retried, edited, or routed away? A handoff designed in five minutes becomes the bottleneck the project was built to remove.

Step 6: Measure, Fix, and Expand
An agent in production is a process, not a project. Four numbers tell you whether it is working.
Task success rate: the share of items the agent completes without human correction. Track it by type, because an average hides a category that is failing.
Human intervention rate: how often a person must touch an item, and why. A rising rate is the earliest warning of drift.
Cycle time and cost per item: against the manual baseline the business measured in Step 1. Without that baseline, there is no case to defend at the next budget review.
Error classes, not error counts: what kinds of mistakes happen. The list becomes the improvement backlog, and the business half of the team is the best source of it, because they see the consequences.
Expand only after the first process is boring. The second automation is cheap when the first one taught you the integration pattern, the approval design and the measurement. It is expensive when the first one is still surprising you.
Step 7: Agent Security: The Three Legs You Must Never Wire Together
An agent that reads untrusted content, reaches private data, and can send information outward is exploitable by design, and the exploit does not require breaking the model. It is enough to leave instructions inside something the agent reads. A support email, a web page it summarises, a document a customer uploads, a calendar invite, a comment in a ticket: each is a delivery surface for text the model may treat as an instruction. This is prompt injection, and it has held the top position on every edition of the OWASP Top 10 for LLM Applications for a reason.
The lethal trifecta. The security researcher Simon Willison named the combination worth memorising: an agent that combines (1) access to private data, (2) exposure to untrusted content, and (3) the ability to communicate externally can be tricked into stealing the data it can reach. Remove any one leg and the attack collapses. This gives the builder a design rule that is far more useful than a filter: at no point should a single agent hold all three capabilities in the same execution path.
Read the trifecta against your own drawing. Take the system page from Step 2 and label each tool with three booleans: does it read private data, does it ingest content an outsider can influence, and can it send data outward (an HTTP call, an email, a post, a pull request, a link a human will click). Then find any path where all three are true. That path is the project's first security finding, and it is found on paper, before any code exists.
Four mitigations, in order of strength.
Break the trifecta structurally. Split the work across two agents or two passes: one that reads untrusted content and produces structured output, and one that holds the privileged tools and never sees the raw untrusted text. This is the strongest mitigation because it removes the ingredient instead of filtering it.
Cap the privilege of the outward-facing tools. A tool that can send email to arbitrary addresses is an exfiltration channel. A tool that can send to an approved internal alias, with a template, is not. Narrow the recipient set, the payload shape, or both, and the worst case becomes noise rather than a breach.
Require human confirmation for outward actions. The confirm step must show the raw action rather than a model-written summary of it: the actual recipient, the actual payload. A summary can be written by the same manipulated model that proposed the action.
Treat every ingestion point as a review point. When the agent is going to act on content, the content's origin belongs beside the proposed action. "This action is based on a document uploaded by an unknown party" is information the human reviewer needs, and it is cheap to attach.
What not to rely on. Instructions telling the model to ignore malicious commands are not a control, because the attacker's text and your instructions arrive as the same kind of tokens. Input filters help against known patterns and miss paraphrase, translation, encoding and images. A system whose security posture is "our prompt forbids that" has no security posture.
Log the untrusted ingestion. The agent's call log from Step 4 should record when a tool returned content from outside the organisation, and which item the agent acted on afterwards. This record is what turns an incident review from guesswork into a timeline, and it is the first thing a serious security review will ask to see.

Step 8: Reliability Engineering for Agents
An agent that works in a demo and fails in production usually fails for mundane reasons: a timeout, an ambiguous tool result, a retry that ran an action twice, a context window that filled up halfway through a conversation. Reliability engineering for agents is the practice of designing for these ordinary failures before they happen, and it maps cleanly onto the four failure classes below.
Class 1: step failure. A tool call times out, returns an error, or returns something the model misreads. The design question for each tool is what the agent should do when it fails: retry, try an alternative, escalate to a person, or stop. The wrong answer is the default one, which is usually an unhandled exception and a task that hangs. Write the failure behaviour into the tool description itself, because the description is what the model reads when deciding what to do next.
Class 2: action duplication. The agent retries a step that actually succeeded, and the customer gets two refunds, two emails, or two orders. This class is the reason for idempotency keys: every irreversible tool call carries a unique identifier so the downstream system can recognise a repeat and do nothing. Retries without idempotency are how an agent turns a transient failure into a customer-visible error.
Class 3: the loop that will not stop. The agent retries a failing step, tries a variant, retries again, and burns the budget. Every agent loop needs three ceilings: a maximum number of steps, a maximum spend per task, and a wall-clock timeout. When a ceiling is hit, the task escalates rather than dying silently, because a task that quietly stops is indistinguishable from a task that was never assigned.
Class 4: context degradation. Long-running agents accumulate history until the model's decisions degrade: earlier instructions get summarised away, or the window fills with tool output nobody will read again. Two countermeasures, and successful systems use both. Summarise and record state deliberately, rather than letting the window fill; and start a fresh execution for each new item, carrying forward only the structured state that task actually needs.
The five practices that follow.
Write the failure behaviour next to the capability. Every tool description states what to do when the tool fails, in the same breath as what it does.
Make irreversible actions idempotent. The identifier is generated by the caller, carried in the request, and enforced by the receiving system.
Set three ceilings per task. Steps, spend, and time, with a named escalation when any of them is hit.
Separate state from chat. The durable state is structured data; the conversation is disposable. A task that cannot be resumed from its structured state cannot be resumed at all.
Replay your failures. Keep a log of failed executions with their inputs, and re-run them against every change to a prompt, a model or a tool. This is the agent equivalent of a regression suite, and it is the single practice that most improves long-run reliability.
The reliability checklist for a live agent
Failure class | The design answer | Where it lives |
Step failure | Declared fallback behaviour per tool | The tool description |
Action duplication | Idempotency key on every irreversible call | The tool interface |
The endless loop | Step, spend and time ceilings with escalation | The orchestrator |
Context degradation | Deliberate state, fresh executions per item | The state design |
A worked example
An agent processes supplier invoices: it reads each PDF, extracts the line items, matches them against purchase orders, and posts the match for approval. In its first month the same invoice is posted twice because the posting call timed out after succeeding, and a second invoice loops for forty minutes against a missing purchase order.
Both defects are class failures rather than model failures. The fix for the first is an idempotency key on the posting call, keyed on the invoice number. The fix for the second is a two-step ceiling plus a rule in the matching tool's description: when no purchase order exists, return "no match" and stop rather than searching variants indefinitely. The agent's accuracy was never the problem. Its failure design was missing, and now both defects are regression cases in the replay log.

The Economics of an Agent: What It Costs to Run
The business case for an agent survives or dies on unit economics, and the numbers belong in the design rather than in the post-mortem. Four costs deserve to be modelled before build, all of them per item processed.
Model cost per item. Every step that calls the model costs tokens, and an agent loop multiplies calls by steps. Model the average number of model calls per item, the tokens per call at the scale your prompts actually produce, and the price of the model tier you will use. A single-call classifier and a four-step agent can differ by an order of magnitude on the same volume. Use the vendor's current pricing page for the numbers and record the date you read it, because prices move.
Tool and infrastructure cost per item. API calls to the systems the agent touches, retrieval queries, and the compute that runs the orchestration. These are usually small individually and visible only in aggregate, which is why they belong in the same per-item figure as the model cost.
Human cost per item. The review, escalation and sampling points from Step 5 are not free, and they are the line most often omitted. If a person spends two minutes per item, that cost dwarfs the model cost at most salary levels. The comparison that matters is against the manual baseline from Step 1, and it should include the reviewer, not just the agent.
The cost of a mistake, weighted. Take the error classes from Step 6, attach the cost of each, and weight by frequency. Then compare that expected cost against the manual process's own error cost. An agent that is thirty percent faster and twice as likely to send a wrong number to a customer is not an improvement, and the arithmetic shows it before the finance review does.
Three rules for the arithmetic.
Model the ceilings, not the averages. The ceiling from Step 8 (steps times tokens times price) is the worst honest case per item, and it is what a runaway loop costs if the ceilings fail. If the ceiling cost is unacceptable, the ceilings or the design need to change.
Charge the human review to the agent's side of the comparison. The review exists because of the agent, and pretending it belongs to the old process hides the project's real cost.
Re-measure after the first month of live traffic. Token consumption per item, escalation rate and retry rate all differ from the model, usually in one direction: upward. The first month's real numbers replace the estimates, and the business case is re-stated with them.
The unit-economics sheet
Cost line | Unit | Source |
Model cost | Per item (calls x tokens x price) | Vendor pricing page, dated |
Tool and infrastructure | Per item | The systems the agent touches |
Human review and escalation | Per item, weighted by the rate | The team running the process |
Expected error cost | Per item, weighted by class frequency | The error log from Step 6 |
Ceiling cost | Per item, worst honest case | The ceilings from Step 8 |
One sentence for the finance conversation. The agent's case is not that it is faster. It is that the same volume costs less per item once every cost and every error is counted. If the sheet cannot show that, the honest move is to narrow the scope to the task types where it can, or to wait for the numbers to change.

From Pilot to Production: The Four Gates
A working agent in a demo is a prototype. Production is a different contract, and four gates separate the two. Each gate has an owner, and none of them is a formality.
Gate 1: the evidence gate. Ten real items, processed end to end, with the outputs reviewed by the process owner against the manual standard. Not synthetic samples, not the demo's prepared cases: items from the live queue, including at least two that are unusual. The output is a written verdict from the owner: usable, usable with edits, or not usable. An agent that cannot clear this gate should not meet a customer.
Gate 2: the failure gate. The four failure classes from Step 8, each one demonstrated to behave as designed: a tool failure that produces the declared fallback, a retried call that does not duplicate an action, a task that hits a ceiling and escalates, a long run that does not degrade. Run this gate on staging, deliberately broken, and keep the log of each behaviour as the evidence. Teams that skip it discover the same defects in production, at the cost of a customer.
Gate 3: the authority gate. The authority map from Step 4, tested: every irreversible tool behind its confirmation, every escalation landing somewhere monitored, every threshold firing when it should. The test for this gate is a person who is not on the project reading the authority map and explaining it back. If they cannot, the seam is still open.
Gate 4: the measurement gate. The dashboard from Step 6, live, with the manual baseline entered, and the four measurements visible to the owner. This gate is what makes the agent's case defensible at the next budget review, and it is the cheapest of the four to pass. It is also the one most often left for later, which is why the first month of production is usually invisible to the people paying for it.
A rule about the sequence. The gates run in order, and a failure at any gate sends the project back to the stage that owns the defect, not forward with a note. A project that passes gate 1 and fails gate 3 does not go live with an exception; it fixes the authority map and re-runs the gate. The temptation to go live with a written exception is the specific temptation this sequence exists to close.
What the process owner signs
The signature at gate 1 is the business half of the team accepting the output, and it needs to be specific to mean anything. Three sentences belong in it: the task types the agent has been shown to handle, the task types reserved for people, and the measurement the owner will use to check the agent is still performing. A signature without those three sentences accepts a demo. A signature with them accepts a process.
Where the business half checks the technical half
The gates are mostly technical evidence, and the business reader's job is to test three claims the technical half is inclined to make optimistically.
"It handles the queue." Ask which items did not go through the agent during the gate period, and why. A trial that quietly routes the difficult items around the agent reports the performance of a favourable subset. The count of routed items is the boundary of today's capability, and the business reader is the right person to insist on it being written down.
"The error rate is low." Ask what the rate is per task type, and what a mistake costs in each type. A single average hides the category that is failing, and the business reader owns the cost side of that arithmetic. The two numbers, rate by type and cost by type, are what turn a quality claim into a decision.
"The dashboard is ready." Ask for the four measurements on one screen, one week of real data, and the name of the person who reads them. A dashboard nobody opens is a project deliverable, not an operational instrument, and the difference is visible in exactly one question: who looked at it last week, and what did they do?
The seam, one more time
Every stage of this lecture has the same shape: the technical half holds facts about what the system can do, the business half holds facts about what the work needs, and the project succeeds where the two sets of facts meet on a page. The gates, the measures, the escalation design and the economics are all different views of that same meeting. Keep the page current, and the agent stays an instrument. Let it fall behind, and the project drifts back to the failure this lecture opened with: an automation, running quietly, answering a question nobody asked it to answer.
A worked example
A logistics team builds an agent that reads delivery exceptions from a carrier portal and drafts the customer notification. At gate 1, eight of ten drafts are usable and two need edits that turn out to follow a pattern: exceptions with a customs component need a different template. The owner adds that task type to the reserved-for-people list, and the signature records it.
At gate 2, the tool that reads the carrier portal times out during the test. The agent retries twice, then escalates, exactly as its tool description declares. But the notification tool turns out to have no idempotency key, and a retried send produced two drafts in the test. The gate fails on that defect, the key is added, and the gate is re-run. In production, a carrier outage in week three produces escalations rather than duplicates.
The reading: three of the four gates found something a demo could not, and the one finding that mattered most was not about the model. It was about the tool interface, and it was caught while the stakes were a staging environment.

What Technology and Business Each Contribute
The two halves of the team own different facts, and the project fails at the seam when either half guesses.
Technology owns: feasibility, architecture, the tool and data interfaces, the failure behaviour, the observability, and the cost of running the system.
Business owns: which process matters, what the output must contain to be usable, who is accountable, what a mistake costs, and when the process has changed enough that the system needs updating.
The shared artifacts are the ones built together: the process map with its decision points, the authority map, the exception profile, and the measurement dashboard. These are the deliverables that let a non-technical owner run a technical system.
One sentence to keep: engineers build what the business describes, so the business must describe the process, the exception and the consequence, and not leave those to be discovered in production.
Feynman Summary: Explain It Like You Are 12
Your school library is drowning in returned books that need to go back on the right shelves. You and a friend build a robot arm that can sort them.
If you build the arm first and let it sort however it likes, it will put books in wrong places, and the librarian will stop trusting it. So before building anything you do this: you ask the librarian which shelves actually fill up fastest, you draw the path a book takes, and you agree on which books the robot may sort by itself and which ones a person must check.
Then the robot is simple and useful. It only does one job, it asks for help on weird books, and every week you look at how many it got right.
That is the whole lesson: the robot is the easy part. The afternoon of questions is the important part.
Mindmap: The Complete Picture

The mindmap gathers the lecture into one view: the six stages of the build, the four agent patterns, the three human touchpoints, and the two columns of ownership that the technical and business halves each bring.

UNOP Sound (University 365 Neuroscience Oriented Pedagogy)
Take five minutes to consolidate your memory. Play the isochronous tone track (10Hz alpha frequency) with your eyes closed. Alpha-frequency tones after a learning session support consolidation, helping move what you just learned from short-term to long-term memory.
[Audio player: UNOP Post-Lecture Isochrone (10Hz, 5 minutes)]
Practical Exercise: Design One Agent for a Real Process
Choose a real process in your organization with a real owner. This exercise is done in pairs if you can: one technical reader, one business reader.
Part 1: Select (15 minutes)
Score three candidate processes against the four properties: volume, describability, error survivability, and position on the routine-to-judgment spectrum.
Pick one. Write the manual baseline: items per day, minutes per item, cost per mistake.
Part 2: Draw (25 minutes)
Draw the workflow as it actually runs, including the workarounds.
Mark the data flows and the systems each one touches.
Mark every decision point and classify it: automate, assist, or keep human. Justify each "assist" with the review the human performs.
Choose the smallest agent pattern that meets the requirement, and write one sentence on why the next pattern up was rejected.
Part 3: Specify (20 minutes)
List the tools the agent needs, at the narrowest privilege that works.
Write the model-facing description of one tool, as you would brief a new colleague.
Define the escalation thresholds and where escalations land.
Name the four measurements and who reads them weekly.
A checkpoint
Show the drawing to someone who was not in the room, from the other half of the team. If they can explain the system back to you, including where a human decides, the drawing is finished. If they cannot, the seam is still open, and the seam is where agent projects fail.
Applied CI-First connection
You chose the process, the exceptions and the escalation points: judgment calls with consequences. The machine carried the drafting, classification and search. Every number in the dashboard is generated fast and interpreted by a human who is accountable for the decision it informs.
Glossary
Term | Definition |
AI agent | Software that uses a model to decide and take actions toward a goal, rather than only producing text. |
Tool (function) calling | The mechanism by which a model requests a specific function with structured arguments instead of writing prose. |
Agent loop | Observe, decide, act, observe again: the cycle that lets an agent complete multi-step tasks. |
Agent pattern | The architecture shape: single call with tools, single agent loop, agent pipeline, or coordinated agents. |
Least privilege | The rule that an agent receives the narrowest access that completes its job. |
Human-in-the-loop | Deliberate design of the points where a person reviews, approves or handles an exception. |
Escalation threshold | The condition under which work leaves the agent and goes to a person. |
Exception profile | The business record of how often a process deviates and what a deviation costs. |
Cycle time | The elapsed time for one item to pass through the process, before and after automation. |
Error class | A category of mistake, tracked over time as the improvement backlog. |
Observability | The logging and tracing that make a live system inspectable, including every tool call. |
Dry-run mode | Operating an agent so that its actions are simulated or held for approval before anything irreversible happens. |
5M2S | 5 Minutes to Success, University 365's microlearning format. |
Quiz: TEST YOUR UNDERSTANDING
1. Which process is the best first candidate for an agent?
A) One done ten times a day that needs senior judgment at every step
B) A high-volume, describable process where errors are survivable and detectable
C) A process that cannot be written down
D) The one with the most impressive demo
2. What are the four agent patterns, in escalating cost?
A) Chatbot, assistant, copilot, autopilot
B) Single call with tools; single agent loop; agent pipeline; coordinated agents
C) Local model, cloud model, fine-tuned model, multi-model
D) Read, write, approve, publish
3. Why must the tool description be written for the model, not the developer?
A) Because models read slower than developers
B) Because the description is what the model uses to decide whether and how to call the tool
C) Because developers do not read documentation
D) Because it improves the model's training data
4. What is the difference between a review point and a sampling point?
A) Review sits before an irreversible or reputational action; sampling checks live output quality periodically after the system is trusted
B) They are the same thing
C) Sampling happens only in development
D) Review is done by the model itself
5. Which artifacts make a non-technical owner able to run a technical system?
A) The model's version number
B) The source code and the API keys
C) The process map with decision points, the authority map, the exception profile and the measurement dashboard
D) The vendor's marketing documentation
Answers: 1-B, 2-B, 3-B, 4-A, 5-C
Related Resources
U365 INSIDE Publications
Lecture: Building Your First AI Agent with Function Calling: the technical foundation, from the first tool call to production patterns
Lecture: Automating Business Operations with AI Agents: the multi-agent workflow for an order-processing pipeline
Lecture: The CI-First Workflow: Applied to Any Field: the division of labor this lecture applies
External Resources
Anthropic: Building effective agents: the pattern taxonomy this lecture's four patterns build on, with worked examples: anthropic.com
OpenAI: Function calling guide: the tool-call mechanics, including multi-call handling: platform.openai.com
Deloitte: State of AI in business: enterprise adoption data for the business case: deloitte.com
LangGraph documentation: library documentation for building stateful multi-step agents: langchain-ai.github.io
Related U365 Lectures
Lecture 1: The CI-First Workflow: Applied to Any Field (UIT, UIB, UIC, UID, Cross-Institute Series)
Lecture 4: The AI Product Launch: From Code to Market (UIT, UIB, UIC, UID, Cross-Institute Series)
Lecture 5: Ethics and AI: A Practical Framework for Every Field (UIT, UIB, UIC, UID, Cross-Institute Series)
U.Copilot for This Lecture
Discuss this lecture with U.Copilot, your AI chat companion trained on this content.
Copy and paste the following prompt into the U.Copilot chat on university-365.com:
You are U.Copilot for Lectures, an AI chat companion specially trained on University 365 lecture content. You are helping a Fellow who just completed the cross-institute lecture "Building AI Agents for Business: A Cross-Discipline Guide". Your role is to help the Fellow design a first agent for a real process. You can: - Score candidate processes against volume, describability, error survivability and shape - Help draw the workflow, data flows and decision points - Choose the smallest agent pattern that meets the requirement - Draft tool descriptions in the form a model needs - Place and specify the review, escalation and sampling points - Define the four measurements and their review cadence Always maintain U365's CI-First approach: the accountable human owns every irreversible action and every commitment, and AI accelerates the drafting, classification and search. Distinguish verified facts from vendor claims, and never present an unverified statistic as evidence. Use the UP-Context-Engineering Method: provide context-rich, role-aware responses that account for the Fellow's field, seniority and constraints.
Next Steps
Score three real processes this week and pick the first candidate with its owner, not for it.
Draw the system page before any code, and review it with both halves of the team.
Write one tool description the way a model needs it, and compare it with the developer description.
Place the humans deliberately: one review point, one escalation rule, one sampling cadence.
Define the baseline before build: items per day, minutes per item, cost per mistake.
The technology half and the business half each hold facts the other cannot guess. The afternoon that merges them is the difference between an automation that survives its first quarter and one that is quietly switched off.
IMPORTANT NOTICE
This lecture is published by University 365 as part of its INSIDE Publications Hub. The content is free to read for all visitors. Lectures in this series may be part of a structured academic program leading to a Micro-Credential for your Career (MCC). To enroll in an academic program, visit university-365.com/tuition.
This content is for educational purposes. Agent frameworks, model APIs and platform policies develop quickly. Verify current specifications and vendor terms against the primary sources linked above before relying on any architecture in production.
Copyright University 365, Inc. All rights reserved. This content is protected under University 365's copyright policies. For permissions or inquiries, contact uda@university-365.com.
Published by the Department of Academics, University 365.
Lecture delivered by the UIT, UIB in collaboration.
Martin Swartz, Dean of Academics, UDA
Signed for the academic year 2026.









Comments