Idea #1
Every LLM call in a production workflow should be wrapped in a larger deterministic process, not exposed directly to user input. The tendency is to treat an LLM like a function: send in user text, read back the answer. This works for toy demos but breaks at enterprise scale because you lose guaranteed behavior: context may not be loaded consistently, the wrong model may run, output format may vary, and there's no place to inject required business logic. The right pattern is to route every LLM invocation through a workflow that handles context injection, conditional routing (e.g., classify the query first, then load only the relevant tools), model selection, and output formatting as hard code steps — the LLM is one node in a graph, not the whole graph. The explicit goal is to make LLM-driven automations as deterministic as possible: the non-determinism is real, but it should be contained to the step that actually requires it. The whole industry is converging on this architecture. The example given is a leave-policy workflow: before the LLM node runs, the workflow loads the applicable policy functions and scopes the agent's capabilities; the LLM then classifies the question (parental leave vs. vacation) and answers using only the pre-loaded tools — the surrounding steps are conventional code and are fully predictable regardless of what the LLM does.
Idea #2
For compliance-sensitive business rules embedded in documents, codify the rules into tested functions rather than relying on RAG retrieval. RAG on a policy document will get the right answer most of the time — but 'most of the time' is unacceptable when the output carries legal or organizational weight, such as HR leave entitlements, benefits rules, or security policies. The alternative is to take the source document and translate each rule into a function with strict input/output contracts and generated test cases, then give the agent access to those functions as tools rather than raw document chunks. The agent now calls a deterministic function that always returns the correct answer for a given input, instead of performing a probabilistic similarity search that might retrieve incomplete or misleading context. This is a qualitative shift in reliability and auditability: every answer can be traced back to a specific, testable function. The HR-handbook example makes the trade-off explicit: uploading the handbook for RAG gives probabilistic retrieval; running it through Oracle AI Agent Studio's policy generator turns it into a set of code functions with test cases, which the agent then calls within a classification workflow — the result is guaranteed-correct answers on leave policy questions, not just usually-correct ones.
Idea #3
Design around the business outcome first, not the agent. The default failure mode when integrating agentic AI is making the agent the entire application — you pick a use case, build an agent, and call it done. This produces something that works in a demo but fails to deliver coherent value because the agent's conversational interface doesn't match how real roles actually get work done. The right inversion is: map the business outcome first (what does someone in this role actually need to accomplish?), design a unified dashboard for that outcome, and then identify which discrete automations within that experience are worth handing to an agent. The agent becomes a tool inside the application, not the application itself. This also gives you natural leverage points for control and review — you can wire a workflow to pre-process inputs, constrain agent scope, and post-process outputs before anything reaches the user. The concrete example is a manager-coaching app: rather than a chat window where a manager asks about team health, the agentic app has preconfigured components — engagement status, objective tracking, a follow-up email composer — each backed by a workflow that calls an agent. The manager gets everything in one view, with the agent doing heavy lifting on each focused task.
Source: Agentic Apps: How Big Companies Are Actually Deploying AI Agents (Cole Medin)
Text summarized and optimized using Anthropic’s models and reviewed by a human.