CTO
“You need one person accountable for technology, from strategy to production.”
- 01Technical roadmap and priorities
- 02Architecture and platform decisions
- 03Production AI systems, from problem framing to rollout
- 04Security and identity governance
Your message has been sent. I’ll get back to you soon.
From business friction to AI in action.
I understand the customer’s problem, turn it into a product or operational solution and lead delivery. Business judgement, product creation, team leadership and hands-on engineering, with AI model harnesses and agentic workflows as part of the toolkit.
I’m a founder and hands-on technology leader with 13+ years taking ideas from business problem to working product. I combine a software-engineering foundation with product strategy, architecture and team leadership. I’ve shipped 20+ products, advised startups and operated businesses across software and hospitality, and today I lead four engineers using agentic coding workflows.
Three seats, one skill set: founder experience, engineering leadership and agentic coding.
“You need one person accountable for technology, from strategy to production.”
“You need a team that ships faster with AI.”
“You have a business idea and need a partner who can build it and take it to market.”
I bring AI initiatives into the wider technology environment, connecting cloud infrastructure, enterprise systems, software delivery and the people responsible for operating them.
I translate business priorities into practical AI initiatives, connecting use-case selection, architecture and implementation. My focus is on solutions that fit the organisation’s workflows and deliver a clear operational benefit.
I design systems in which AI agents work with data, tools and enterprise applications to perform defined tasks. These workflows bring intelligence into processes such as classification, investigation, reconciliation and decision support.
I use AI coding agents to help build applications from concept through implementation. I direct the development process, define the architecture, review the outputs and retain responsibility for engineering decisions and delivery.
I set the technical roadmap and make the architecture calls: build versus buy, platform choices, integration patterns and the security model, each tied to a business priority.
I take products from a business problem to a shipped release: scoping the MVP, organising delivery, building hands-on where it matters and getting it to customers.
AI agents are part of both the solutions I create and the way I develop them. I provide the direction.
Start with the business problem: what the system should achieve and where human judgment is required.
Design how it should work. Agents work with information and tools to carry out tasks and support decisions.
Coding agents turn requirements into applications. I review the outputs and validate before release.
Into production, then adoption and continuous improvement.
An AI-supported risk system that uses historical assurance data to help teams identify participants and audits requiring closer attention.
An agent-driven workflow that classifies, prioritises and routes reports of sustainability incidents, helping assurance teams focus their response.
An automated reconciliation workflow that reduced a previously annual manual cycle to near real time.
An AI-supported tool that flags potentially manipulated or forged documents for further review.
An Ayurvedic self-care application developed for an external client across Android, iOS and backend, using AI coding agents under my direction.
A dating and community app for the spiritual and yoga community. In development for an external client through an agentic workflow.
A community and social-app project connecting people interested in spirituality and personal development, using an AI-assisted product-development approach.
Other projects include Club Ecstatica, an ecstatic-dance community app in development; AI-enabled project management tools; and a web-scraping agent system.
Lead four engineers across IT operations, platform architecture and AI delivery. Shipped four AI agentic systems and established the agentic coding workflow used across the team.
Led global IT operations with L1–L3 support. Delivered the Microsoft 365 migration, customised Dynamics CRM and built membership and invoicing tools in PHP and Python.
Advised founders on product strategy, software and cloud architecture. Guided distributed teams, delivery priorities and independent QA, helping translate early ideas into practical products.
Led product strategy, architecture and delivery. Built Cense Cloud, a cloud ERP serving around 60 SMEs; NicNac, an on-demand delivery mobile app; and Veins, an on-demand blood-donation mobile app.
Advised early-stage founders on technology choices and product development.
Use an invoice harness for intake, with payment kept separateExtract documents into a review queue, check the numbers and surface exceptions before accounting decisions.Read note
Separate agreed actions from suggestions in meeting notesA meeting harness should preserve uncertainty, resolve ownership and prevent duplicate tasks.Read note
Turn one approved brief into content without inventing the storyUse a structured brief, a source list and explicit claim checks to generate reusable channel drafts.Read note
Build a support-answer harness that knows when to stopRetrieve approved knowledge, draft within policy and route unsupported answers to a person.Read note
Compare supplier quotes with a reusable evidence tableFix the comparison fields, preserve the source evidence and flag missing terms before a person chooses a supplier.Read note
End an AI coding session with a handoff, not a memory dumpA concise record of state, evidence and open work helps the next session resume without trusting a stale summary.Read note
Make a bigger coding model earn its placeUse the same acceptance checks to compare model choices, including retries and human review.Read note
Ask AI to build one working slice before the whole featureConnect the interface, logic and storage for one realistic path before multiplying screens and features.Read note
Build a small context pack instead of pasting the whole repositoryGive the agent the files, constraints and examples that define this change, then let it retrieve more when needed.Read note
Give your coding agent a failing example before asking for a fixA reproducible failure turns a vague debugging request into a change you can evaluate.Read note
Build a tomorrow brief that leaves your calendar aloneUse a read-only calendar and your own notes to prepare for the day without giving an agent control of it.Read note
Create a digest that tells you what changedWatch a few trusted sources and send yourself only meaningful changes, with links back to the evidence.Read note
Give your screenshots a next actionA small review queue can turn saved screenshots into useful reminders, references and tasks.Read note
Build a return-window reminder from the receipts you already saveUse AI to organise purchase evidence while letting verified dates and ordinary rules drive reminders.Read note
Turn a voice note into a decision you can actually useCapture an idea once, then turn it into a small, reviewable action without inventing the missing details.Read note
Who Owns the AI Between Demo and Delivery?The AI Solutions Architect connects business decisions, system boundaries and operational ownership so useful prototypes have a credible route into daily work.Read note
Build a Five-Year AI Budget That Can ChangePlan for durable capabilities, fund delivery in stages and revisit assumptions as the economics and use cases change.Read note
Revisit Your Strategy Where the Work Has ChangedUse AI capability changes to revisit specific business assumptions, with evidence from the workflow and a clear route to adoption.Read note
AI Literacy Starts With Everyday DecisionsPractical training helps people decide what to share, what to verify, when to act and when to stop.Read note
Secure AI Begins With Bounded AccessApply familiar security disciplines to the new pathways created by models, tools and retrieved content.Read note
Decide What Data Your AI Is Allowed to SeeAn approved model does not automatically make every document appropriate input. Govern the complete information path.Read note
Put Company Policy Inside the Agent’s HarnessTranslate written rules into permissions, approval gates, evidence and exception handling that operate with the workflow.Read note
Human Oversight Needs Time, Context and AuthorityA review step is useful when the person can understand the evidence, challenge the recommendation and change what happens next.Read note
AI Incidents Need a Rehearsed ResponsePlan how to contain an agent, preserve useful evidence, restore service and learn from mistakes before an incident occurs.Read note
A Governance Scorecard for the AI Leadership TeamUse a compact view of value, reliability, control and adoption to decide which AI services to expand, improve or retire.Read note
The model is the stallion. Build the harness.Power becomes useful when the surrounding system gives it direction, boundaries and feedback.Read note
Start at the client’s desk, before opening the model catalogueAn embedded approach finds the real work, its exceptions and the people who must trust the result.Read note
EU data residency and EU inference are different questionsA European storage location is one part of the architecture, not a complete answer about processing.Read note
The real AI bill is cost per successful workflowToken prices matter. Retries, review effort and failed work determine whether the system is economical.Read note
A useful agent needs a narrow job and a clear action boundaryAn illustrative onboarding pipeline shows where model judgement helps—and where ordinary software should decide.Read note
Reliability means passing the same standard, not repeating the same sentenceEvaluate outcomes, exceptions and actions across repeated runs before expanding autonomy.Read note
Your coding agent needs a delivery systemRepository context, bounded tasks and release evidence matter as much as code generation speed.Read note
More agents should earn their placeParallelism is useful when the work separates cleanly and the coordination cost is justified.Read note
Build the prototype around the question you need answeredAgentic development can accelerate learning when the product slice and production gap are explicit.Read note
The harness must evolve with the model and the businessKeep interfaces stable, measure changes and retire controls that no longer help.Read note
Agentic AI without the hype: where agents earn their placeAn agent is a language model, a set of tools and a loop. Where that combination pays off in real organisations, and where a plain workflow is still the better choice.Read note
Choosing a language model in 2026: what actually mattersNew models arrive every few weeks. The leaderboard rarely decides what works in production; your tasks, your data and your constraints do.Read note
Frame, orchestrate, evaluate, ship: how I take AI from idea to productionThe four stages I use to turn an AI idea into a system people rely on, and the question each stage has to answer before the next one starts.Read note 38 notesAll notesExtract documents into a review queue, check the numbers and surface exceptions before accounting decisions.

A PDF invoice is a good example of where AI and ordinary rules have different jobs. The model can help read an inconsistent document. Arithmetic, duplicate checks and approval rules should not depend on a fluent explanation.
An invoice-intake harness separates those steps. The first version should prepare records for review, with no authority to pay suppliers or change bank details.
Start with supplier name, invoice number, invoice date, currency, net amount, tax amount, total and source file. Ask for missing or unreadable fields to be marked explicitly. Preserve the original document for the reviewer.
Use a small set of synthetic invoices for the first test. There is no need to expose real account details while deciding whether the workflow understands your required fields.
A visual workflow might be: dedicated upload folder → document extraction → fixed output fields → arithmetic and duplicate checks → exception queue or review-ready record.
Check net plus tax against total using ordinary decimal arithmetic with an explicit rounding tolerance. Check likely duplicates using supplier identifier, invoice number and other relevant fields; do not rely on the filename alone. A renamed attachment can still be the same invoice.
A structured parser can help enforce the expected field layout. It cannot establish that the document is authentic or that the extracted values match the original. Read n8n’s structured-parser documentation.
If the currency is missing, the sums do not reconcile or two documents appear to represent the same invoice, route the record to a named reviewer. Include the failed check and the relevant source, rather than a generic error message.
Treat bank-detail changes and payment approval as separate processes owned by the finance team. A model-generated match or a well-formed record is not approval to move money.
Try a clean invoice, a duplicate with a new filename, a blurred total and a credit note. Decide how each should be handled before evaluating the workflow. A credit note must not silently become a positive invoice because the template expects a total.
Measure extraction corrections, duplicates missed and reviewer time. Include model usage, retries and exception handling when calculating cost per accepted record. A low-cost model may be enough for some documents; that is a result to measure, not a promise.
This harness can often be assembled from visual workflow components and existing document services. Connector availability and document quality determine how much configuration is needed. The practical benefit is a consistent intake process whose uncertain cases remain visible to the people responsible for the accounts.
A meeting harness should preserve uncertainty, resolve ownership and prevent duplicate tasks.

“We should probably ask Maya next week.” That sentence can become “Maya will deliver next week” in a careless meeting summary. The words are similar; the commitment is different.
A meeting-action harness should preserve that distinction. Its goal is a reviewed action record, not an impressive-looking task list after every call.
Define the fields before choosing the model: action, explicitly agreed owner, due date if stated, status and transcript evidence. Use separate statuses for agreed, proposed and unresolved.
If no owner accepted the task, leave ownership unresolved. If someone says “Friday”, use the meeting date and time zone to propose an interpretation for review rather than silently assigning a date when the context is ambiguous.
Keep the relevant transcript excerpt attached. A reviewer should not need to replay the whole meeting to discover why a task exists.
The visual workflow is: approved transcript arrives → extract action candidates → validate fields → route unresolved items to review → create only approved tasks. Use your organisation’s rules for recording, access and retention before connecting real meetings.
Human-review features in a workflow builder can pause a tool action for a decision. They are useful when turning extracted suggestions into changes in another system. See n8n’s human-review example.
The meeting chair or relevant owner should review the commitments. An automatically assigned task can create confusion even when it is technically easy to undo.
Give each approved action a stable identifier linked to the meeting and source item. Check whether that identifier has already been written before creating a task. If a run fails halfway through, rerunning it should not create a second set of commitments.
Keep a correction route. If the owner or deadline changes during review, save that decision rather than asking the model to reinterpret the entire meeting until it produces the desired answer.
Use a short fictional transcript containing a proposal, an explicit agreement, a rejected idea and a changed deadline. Decide the expected actions manually, then compare the workflow’s output. Count invented owners and dates separately from harmless wording differences.
This is a practical no-code harness when your transcript and task tools have suitable connectors. It still requires configuration, permissions and maintenance. The reliable target is consistent treatment of evidence and approval, not identical prose on every run. The most valuable output may be one agreed task and two clear questions.
Use a structured brief, a source list and explicit claim checks to generate reusable channel drafts.

A model can turn a short product note into an impressive launch story. It can also add a customer outcome, a feature or a statistic that nobody approved.
A content harness should make that expansion visible. Its job is to adapt an approved story to different channels while preserving the facts and keeping publication under editorial control.
Create a brief form with the audience, purpose, approved facts, evidence links, available product features, prohibited claims and call to action. Separate factual inputs from stylistic preferences.
For example, “the tool exports a CSV” is a product fact. “Make the copy confident and direct” is a writing preference. The second instruction must not turn the first into “exports to every business system”.
If you have no customer result or performance measurement, leave that field empty. A strong piece of content can explain a useful workflow without inventing a case study.
A visual workflow can read the approved brief, generate a blog outline and social drafts, check length and required fields, and place the results in an editorial queue. Use saved channel templates for structure, tone and formatting.
Keep a list of claims beside each draft and require a link back to the relevant brief item or source. Rules can check whether a link or required field exists; an editor still needs to judge whether the evidence supports the wording.
A structured-output component can help keep the same fields across runs. It does not verify the truth of the prose. See n8n’s parser documentation.
Generate drafts first. A person checks factual accuracy, tone, confidentiality and image suitability. Keep the approval attached to the specific version; later edits should not inherit it automatically.
For images, define the visual system separately: palette, aspect ratio, typography and whether people are illustrative or real. A generated face should not imply a customer testimonial or an employee identity.
Use a brief with no statistics, one with an unresolved feature and one with an explicitly prohibited claim. The expected output should preserve those gaps. If the model fills them with attractive inventions, the workflow is not ready for unattended drafting at scale.
You can build much of this with forms, tables and visual automation connectors. You still configure instructions and maintain the templates. The harness removes repetitive briefing and adds reviewable boundaries; it does not remove editorial responsibility.
The useful measure is time to an approved, accurate draft across channels. Producing more words is easy. Preserving the story is the work.
Retrieve approved knowledge, draft within policy and route unsupported answers to a person.

A customer asks whether a service supports a particular export format. A general prompt may produce a convincing answer from old information or from assumptions about similar products.
A support-answer harness starts with the company’s approved information and a clear rule for what happens when the answer is missing. The first useful version can produce drafts for a support agent without sending anything to the customer.
Select a small, maintained set of support articles. Record their versions or update dates. The workflow should retrieve material the current user is permitted to see, rather than searching every internal document indiscriminately.
Request a draft answer, supporting source references and an “answer supported / needs review” status. Do not treat a model-generated confidence percentage as proof. The reviewer should be able to open the source and verify the actual claim.
If the sources conflict or omit the requested feature, the useful outcome is an escalation with the unanswered question.
A practical sequence is: new ticket → select relevant approved articles → draft response → check required fields and source presence → review queue. Keep customer account actions, refunds and outbound sending as separate capabilities with their own permissions.
Tools such as n8n document human approval around AI tool calls. That can support a deliberate review boundary when a workflow is ready to act. Read the human-review documentation.
No-code still needs setup: connectors, access controls, retrieval configuration, saved instructions and test cases. The benefit is a reusable process, not the absence of engineering decisions.
Build a small evaluation set with a known answer, an outdated feature, conflicting documents and a request outside policy. Include a ticket that contains instructions telling the assistant to ignore its rules. Customer text is material to handle, not authority to expand permissions.
For each case, decide in advance whether a draft or an escalation is correct. Track unsupported claims, unnecessary escalations and the time an agent spends reviewing the result.
A citation can still point to text that does not support the answer. Check that relationship during evaluation instead of accepting source links as decoration.
My target would be a support agent who can verify a useful draft quickly and see why another case was held. The harness should make it easier to be correct and easier to stop when the evidence runs out. It cannot guarantee that every generated sentence is true.
Fix the comparison fields, preserve the source evidence and flag missing terms before a person chooses a supplier.

“Which quote is best?” is an easy question to ask a model and a difficult question to answer responsibly. One supplier includes delivery, another excludes it and a third quotes a different quantity. A fluent summary can hide those differences.
A model harness makes the comparison process explicit. Here, the harness is a saved workflow around the model: approved inputs, fixed fields, validation, evidence and a human decision. You configure it once and reuse it, instead of reconstructing the task in a chat every time.
Choose the fields with the person who will make the decision: supplier, item, quantity, unit, currency, net price, delivery cost, lead time, exclusions, quote expiry and source reference. Keep missing values empty and give them an explicit “not supplied” status.
A quote for 100 units must not silently become comparable with one for 10. Likewise, missing delivery cost is not zero delivery cost. Put incompatible units and currencies in an exception column rather than asking the model to guess a conversion.
A first no-code design is: upload form → document extraction → structured fields → required-field and consistency checks → comparison table → review notification. A builder such as n8n can supply visual workflow components; the exact document and storage connectors depend on your systems.
Save the extraction instructions inside the workflow. They still exist, but the user no longer needs to write them for every batch. Use a spreadsheet or deterministic calculation step for arithmetic after a person verifies the relevant commercial assumptions.
n8n documents a Structured Output Parser for schema-shaped output. A schema helps enforce format; it does not prove that extracted prices or terms are correct. Read the parser documentation.
Try three invented quotes: one complete, one missing delivery cost and one with a different unit. The expected behaviour is an honest comparison with exceptions, not a winner on every run.
Keep the original documents beside the table. The buyer decides which exclusions matter and whether clarification is needed. Do not let this first workflow place orders or negotiate terms.
If you want a score, define and approve the weighting outside the model and show the calculation. An unexplained AI ranking makes the process harder to audit.
The repeatable part is the comparison standard: the same fields, checks and decision boundary. Wording may vary, extraction can still fail and a stronger model may sometimes help. Measure field accuracy and review time on representative quotes before claiming savings. A harness is valuable when the reviewer can see what was compared and what is still unknown.
A concise record of state, evidence and open work helps the next session resume without trusting a stale summary.

A long coding session can finish with a surprisingly vague note: “Most of the feature is done.” The next session then spends time rediscovering what changed, what passed and what is still a hypothesis.
A useful handoff is smaller and more precise. It should let another developer—or another agent session—verify the current state before continuing.
Ask for the task objective, current branch or revision, changed files, checks actually run and unresolved work. Include links or paths to the relevant artifacts. Do not paste the whole conversation into the repository.
For example: “The export now preserves column order. The sample-data regression test passed. The large-file path has not been exercised. Next step: run the existing performance fixture before changing buffering.” That is more useful than a confident claim that the export is complete.
Distinguish observed facts from proposed next steps. “The test timed out” is an observation. “The database may be unavailable” is a hypothesis until checked.
At the start of the next session, have the agent inspect the working tree and compare it with the handoff. Someone may have changed a file or committed a different version. The saved note is a guide, not a replacement for current evidence.
Keep secrets, customer data and unnecessary logs out of the handoff. A test command and a concise result are usually more useful than a full terminal transcript. Preserve detailed diagnostics separately when they are needed and safe to retain.
A strong next step names both the action and its purpose: “Verify that a duplicate request does not create a second record.” It should not quietly authorise a production deployment or an unrelated refactor.
Record any decisions that must remain with a person, such as choosing a data-retention policy or accepting a breaking API change. That stops a later session from treating an unresolved business choice as implementation detail.
Anthropic’s context-engineering guidance discusses maintaining useful information over longer work. This handoff pattern applies that idea to a reviewable engineering artifact. Read the guidance.
Try a five-minute handoff at the end of your next agent session. On resumption, measure how long it takes to identify the actual state and next useful action. The best handoff reduces rediscovery without pretending the work is more complete than it is.
Use the same acceptance checks to compare model choices, including retries and human review.

Using the most capable model for every coding step is a simple default. It may also spend more than the task needs. Sending everything to a smaller model can create the opposite problem: cheap attempts that become expensive to review and repair.
A useful experiment is to route work by observed performance on your repository. Keep the acceptance standard fixed while changing which model does the work.
A mechanical rename, a failing-test diagnosis and a change to an authentication boundary are different jobs. Group a few representative tasks by type and consequence. Do not assume a model that formats documentation well will make good architectural decisions.
For an initial trial, choose low-impact changes in an isolated branch. Record the starting revision, task brief and checks. Run comparable tasks under controlled conditions and review the results using the same criteria.
Avoid sending confidential code to a service your organisation has not approved. Model selection includes the deployment and data-handling arrangement, not just capability.
A reasonable experimental policy might allow one attempt and one bounded repair for a narrow task. If a required check still fails, stop and request a human decision or route to a more capable model with the failure evidence. The exact limit is a design choice to test, not a universal best practice.
Do not let the model’s own confidence determine acceptance. Use the actual test results, diff, requirement coverage and human review. A stronger model can also be confidently wrong.
Anthropic describes routing work between specialised paths, including models with different capability and cost. The practical extension is to test that routing against your own accepted changes. Read the routing discussion.
For each accepted change, record model usage, repeated context, tool runs and review time. Track rejection and escalation rates as well. Lower token cost is useful only if the total workflow still meets the quality bar.
Some tasks may be cheaper with ordinary scripts. Some may justify the stronger model immediately. Others may benefit from a small model preparing context for a human or a stronger model.
I would keep the first routing table short and revisit it when the model, codebase or task mix changes. The outcome to optimise is a maintainable accepted change, not the cheapest individual response.
Connect the interface, logic and storage for one realistic path before multiplying screens and features.

AI can generate the appearance of a large product quickly. Screens, routes and components accumulate. The difficult question is whether one real user action works from beginning to end.
A useful coding tactic is to ask for a thin vertical slice: one narrowly scoped path through the interface, application logic and persistence. It should be small enough to review and real enough to expose integration problems.
Imagine a simple client portal. Start with “an authorised user can create one project and see it after a page reload”. That outcome connects input, validation, storage and retrieval. It is more informative than generating every dashboard screen before any data survives a refresh.
Write the acceptance checks first. What fields are required? What happens if the name is empty? Can another user see the record? What should a failed save look like?
Ask the coding agent to implement that path using the existing project conventions. Keep new dependencies and architectural changes justified by the slice, rather than by a speculative future roadmap.
Sometimes a prototype needs a mock service. That is fine if the mock is visible and the limitations are recorded. Do not call a workflow integrated when it is actually displaying local sample data.
Ask the agent for a short list of real integrations, temporary stubs and missing production work. If authentication is simulated, say so before anyone mistakes the demonstration for a deployable product.
Run the action in the UI, reload the page and inspect the stored result. Test a relevant failure case. Automated checks can cover important behaviour, but seeing one success screen alone does not establish persistence, permissions or recovery.
Once the slice works, expand one dimension at a time: another field, an edit operation, a second user role. Each addition should preserve the working path you already verified.
This approach gives the agent feedback while the change is still understandable. It also gives a founder or product owner something meaningful to react to: a real outcome with visible tradeoffs.
For your next AI-built feature, replace “build the portal” with one end-to-end user action and a few checks. Measure time to a reviewed, working slice. A smaller first delivery can reveal the expensive assumptions before they spread through the rest of the product.
Give the agent the files, constraints and examples that define this change, then let it retrieve more when needed.

A long prompt can look thorough while hiding the few facts that matter. If the agent receives old requirements, unrelated logs and several competing implementations, it may spend its effort reconciling noise.
For a bounded coding task, I would start with a small context pack. Its purpose is to make the change legible: what should happen, where the relevant behaviour lives and what must remain true.
Include the desired user outcome, the likely entry points, one representative example, the constraints and the checks that define completion. Link to actual files rather than copying large sections that can go stale.
For a CSV export change, that might mean the export handler, the shared date formatter, a sample input row, the required column order and a test covering the output. Add a constraint such as “preserve the existing download endpoint”.
Separate durable repository conventions from task-specific instructions. The project’s normal build and test commands belong in a maintained repository guide. The exact export columns belong in the task brief.
Do not forbid exploration. Ask the agent to inspect the relevant files and explain when another dependency matters. A short context pack should be a useful starting point, not an artificial blindfold.
If the implementation crosses a shared component or data contract, the agent needs that context too. Conversely, a folder full of archived design notes should not automatically enter every request.
Anthropic’s context-engineering guidance treats context as a limited resource that needs active selection. That supports this practical habit: keep the working brief focused and retrieve supporting detail as the task develops. Read the guidance.
Try the same kind of small task with your usual brief and with a context pack. Compare clarification rounds, unrelated file changes, missed constraints and review effort. A shorter prompt that omits a critical dependency is worse than a longer useful one.
Before accepting the result, check whether the agent used the current code and requirements. Generated notes can become stale just like human documentation. Record the relevant revision when you save a reusable task example.
The aim is enough context for a good decision, with a clear route to more. This makes the brief easier for both the agent and the human reviewer to understand.
A reproducible failure turns a vague debugging request into a change you can evaluate.

“The filter is broken. Fix it.” A coding agent can respond to that instruction with a plausible change that solves a different problem from the one your user encountered.
A better starting point is a small reproduction. Show the input, the expected behaviour and the observed failure. The agent then has evidence against which to check its work.
Suppose a product search should keep the selected category when a user moves to the next page. Instead, page two shows every category. Give the agent a short sequence: choose a category, move to page two, observe that the category filter disappears. State the expected result separately.
Use a local or staging environment with safe test data. Include the relevant route, a minimal example and any useful error output. Avoid pasting a whole production log full of unrelated records.
Ask the agent to reproduce the issue before changing the implementation. If it cannot, the first deliverable should be an explanation of what is missing, not a speculative rewrite.
Where an automated regression test is appropriate, make it fail on the original code for the right reason. A test that passes before the fix provides no evidence that the bug was repaired. A test that fails because the environment is broken provides the wrong evidence.
Review what the test asserts. Does it check the user’s visible result, or merely mirror the code the agent just wrote? Keep the test independent of incidental implementation choices where practical.
Then request the smallest change that resolves the failure while preserving the surrounding behaviour. A paging bug should not automatically trigger a redesign of the search system.
The final handoff should state the reproduced behaviour, what changed, which checks actually ran and what remains unverified. Commands the agent suggests running are not the same as commands it executed successfully.
For a visual issue, a before-and-after screenshot may be more useful than a new unit test. For a data transformation, representative input/output examples may provide the clearest check. Choose evidence that matches the failure.
Anthropic’s agent guidance describes execution feedback as a way to check coding progress. The practical application here is narrow: turn the reported bug into observable evidence before accepting a repair. Read the engineering guidance.
Try this on the next small bug. Compare time to an accepted fix, including review and rework, with your usual “fix this” workflow.
Use a read-only calendar and your own notes to prepare for the day without giving an agent control of it.

A calendar tells you where to be. It does not always tell you what to prepare. The gap between those two things is a useful place for a small AI workflow.
Imagine an evening brief that lists tomorrow’s meetings, the material you intended to read and the unresolved questions from your own notes. The first version can be read-only. It does not need permission to move meetings, contact attendees or make commitments.
Select one calendar and one folder of relevant notes. For a personal trial, use invented meetings or your own non-sensitive commitments. At work, use approved tools and respect document permissions rather than copying everyone’s files into a shared prompt.
For each event, ask the model for the event title, time, linked preparation material and one possible preparation action. Require every action to name its source. If there is no agenda, the brief should say “no agenda found” rather than invent one from the meeting title.
The workflow might be: evening schedule trigger → tomorrow’s events → matching notes by explicit link or identifier → short brief → private notification. Start with explicit links; fuzzy name matching can attach the wrong person’s notes to a meeting.
“Meeting at 10:00” is calendar data. “Review the proposal beforehand” is a suggested action based on the attached material. Display them differently.
Use the calendar’s time zone and handle all-day events separately. A date-only item should not turn into a midnight appointment. Avoid guessing travel time or other people’s availability unless you have reliable inputs for those specific tasks.
Look for missing events, stale notes, duplicated preparation actions and incorrect time zones. Include a cancelled meeting and a recurring meeting with a changed time. The brief should reflect the current event record, not an older email invitation.
Measure whether it helps you arrive prepared, rather than how sophisticated the summary sounds. If five meetings produce five obvious suggestions, the workflow may need better source notes instead of a bigger model.
This is how I would introduce everyday AI: give it a limited job, reliable inputs and a result you can verify. Once the brief is genuinely useful, add an approval step for creating preparation tasks. Calendar changes can remain a separate, explicitly approved action.
Watch a few trusted sources and send yourself only meaningful changes, with links back to the evidence.

A daily summary can become one more thing you ignore. If it repeats yesterday’s information in new wording, it has added reading rather than removed it.
A more useful experiment is a change-only digest. Choose a small subject you care about: release notes for tools you use, updates from a local club or a handful of research feeds. The workflow should tell you what is new, where it came from and why you might want to look.
Start with three official feeds or pages that permit this kind of access. Use feeds and documented integrations where available. Record the source URL, publication date and the previous version or last-seen item identifier.
Before calling a model, compare the current input with what you have already processed. If nothing changed, stop. A deterministic comparison is often enough to avoid paying for another summary of the same material.
If a page contains rotating adverts or navigation changes, isolate the relevant content so noise does not trigger a new digest.
Give the model the previous and current relevant text. Request three sections: new facts, practical implications and unanswered questions. Each new fact should point back to the source. Keep interpretation visibly separate from what the source actually says.
For example, a release note might announce a new export format. The fact is the format’s availability. “This may simplify our monthly handoff” is an interpretation to check against your own process. A model should not claim you will save an hour without evidence.
Send a digest only when the change passes your relevance rule. Otherwise, save the check result quietly. Start with delivery to yourself and keep any onward sharing manual.
Include a “last checked” timestamp and distinguish an unavailable source from an unchanged one. Failed retrieval must not produce “nothing new”. If only two of three sources loaded, say so.
A useful test is to compare a week of this digest with your normal reading. Did it surface relevant changes? Did it miss anything important? How often did it interrupt you unnecessarily?
This design gives AI a bounded reading task. The source list, change detection and notification policy do much of the work. My preference is a small digest that earns attention over a long summary generated simply because a schedule fired.
A small review queue can turn saved screenshots into useful reminders, references and tasks.

Screenshots are a fast way to save something and a slow way to find it again. An event poster, a book recommendation and a useful error message all end up in the same visual pile.
A practical AI use case is to give each screenshot a small amount of structure: what it contains, why you might need it and what should happen next. You can try this without building a personal knowledge platform.
Choose ten non-sensitive screenshots and put them in a dedicated album or folder. Ask a vision-capable model to return a short description, one category and a proposed next action. Use a small category list such as event, reference, task and unclear.
For an event screenshot, request the visible date and venue text separately. For a book recommendation, request the visible title and author. Tell the model to leave unreadable details blank. It should not complete a cropped title from memory or decide which year an undated event belongs to.
The next action is a suggestion. “Check whether this event is still upcoming” is more useful than silently creating a calendar entry from an ambiguous poster.
A visual workflow can watch the folder, analyse each new image and add a row to a review table. Include the image, extracted details and suggested action. After review, move the row to a task list, a reference collection or the bin through your normal manual process.
Use a file identifier or fingerprint to avoid processing the same image repeatedly. Keep the first version read-only with respect to your calendar and task system. You can add approved writes once the extraction is useful.
Include a blurry screenshot, a date without a year and an image containing two unrelated items. Ask whether the model showed uncertainty where it should. A neat table can disguise a bad interpretation, so inspect the source alongside the result.
Never execute commands, open unknown links or follow instructions merely because they appear inside an image. The screenshot is material to classify, not authority over the workflow.
I would judge this experiment by retrieval: can you find the thing you saved and decide what to do with it faster? If the automation just creates another pile, simplify the categories. The smallest useful version is a ten-image review queue that helps you close a few open loops.
Use AI to organise purchase evidence while letting verified dates and ordinary rules drive reminders.

The problem with a purchase is rarely remembering that you bought it. It is remembering where the receipt went, which policy applied and when you meant to make a decision about keeping it.
AI can help organise that evidence. The useful automation is a receipt inbox with a reminder, rather than a model guessing your rights or a retailer’s policy.
Start with three receipts for ordinary purchases. Add the policy or confirmation that actually applies to each purchase, if available. Remove payment details and anything the workflow does not need.
Ask the model to extract the retailer, item, purchase date, order reference and any return-window wording present in the supplied material. Require a source reference for each field. An absent deadline should remain absent.
A phrase such as “returns within 30 days” may leave important questions unresolved: 30 days from purchase or delivery, and are there exceptions? Put those questions in a review column. Do not let the model turn incomplete wording into a precise date.
After you verify the relevant date, use a spreadsheet formula or calendar rule to create a reminder a few days earlier. That arithmetic does not need a language model. Keep the original source attached so you can check conditions when the reminder arrives.
A folder-triggered workflow can extract receipt fields into a sheet and send uncertain entries to a review list. Use the order reference to detect duplicates before creating reminders. A forwarded confirmation and a downloaded PDF may describe the same purchase.
This is a personal organisation aid. Consumer rights and retailer policies vary, so check the applicable terms rather than treating an AI output as legal advice.
Use one folder, one table and one reminder calendar. Keep calendar writes behind approval until you trust the date handling. Test a receipt without a policy, two copies of the same receipt and a confirmation where the purchase and delivery dates differ.
The result you want is a useful reminder backed by evidence. A row that says “deadline needs checking” is better than a confident countdown based on a guess.
My practical rule is to use AI for reading messy inputs and ordinary software for counting days. That split often makes an everyday automation easier to understand and cheaper to run. Compare the review effort with your current habit before connecting a whole mailbox.
Capture an idea once, then turn it into a small, reviewable action without inventing the missing details.

The useful part of a voice note is often buried in the middle. You remember a problem while walking, talk through three possibilities and finish with a decision. Later, the recording sits untouched because listening again feels like another task.
A small automation can make the note easier to use. The goal is to preserve the decision, the uncertainty and the next action in a form you can check quickly.
Record a short note about a low-stakes personal project. For example: “I could run the workshop on Tuesday, but I still need to check the room. Ask Sam about availability. Friday is the backup.” Use a transcription tool you already trust, then ask AI to produce four fields: decision, next action, unresolved question and supporting words from the transcript.
In this example, Tuesday is a proposal. It should not become a confirmed workshop date. The useful action is to ask about the room; the useful uncertainty is that the booking is unresolved.
Save that instruction as a reusable template. You should not have to re-explain the format every morning.
A practical visual workflow is: new recording in a dedicated folder → transcription → extraction into the four fields → review in a note or task inbox. Start with manual approval before anything reaches your calendar or someone else’s inbox. Depending on the apps you use, this can be assembled with existing connectors; check recording access and transcription support before choosing the builder.
Keep the original recording or transcript linked to the result. If the model turns “might” into “will”, the evidence is one click away. When no action was agreed, the right output is “no agreed action”, not a task manufactured to fill the box.
Try a recording with two names, a date you correct halfway through and a thought you explicitly reject. Does the result preserve those distinctions? If it fails, improve the template or review step before adding more automation.
For a first trial, compare five notes processed this way with five you organise manually. Measure the time spent capturing, reviewing and correcting them. A polished summary that takes longer to fix is not a useful saving.
I would start here because it connects AI to a real moment of friction. One small capture habit becomes a dependable place to pick up your own thinking. Keep other people’s confidential information out of a personal trial, and use an approved workspace for work recordings.
This is an illustrative workflow recipe, not a claim that a particular app provides every step out of the box.
The AI Solutions Architect connects business decisions, system boundaries and operational ownership so useful prototypes have a credible route into daily work.

A convincing AI demo can leave a surprising number of decisions untouched. Who can use it? Which records may it read? Who accepts an incorrect action? Who maintains the integration after the pilot team moves on?
Those gaps are where I would start an AI architecture engagement. Sit with the people doing the work. Follow a case from arrival to completion. Find the handoffs, exceptions and decisions that the demo never encountered.
The AI Solutions Architect should connect the business process, data flows, model harness, security boundaries and operating model. The role needs enough technical depth to challenge a design and enough business understanding to explain its tradeoffs.
That person does not become the owner of every risk. The process owner still defines an acceptable outcome. Security, privacy and legal specialists retain their responsibilities. Engineering owns implementation and operation. The architect makes the dependencies and unresolved decisions visible, then brings the right people together to resolve them.
In a smaller company, this can be an explicit responsibility within an existing role or an embedded external engagement. A new title alone will not unblock delivery.
I would begin with one page: the intended outcome, users, data sources, permitted actions, approval points, success measures and named owners. Add the conditions under which the system must stop or hand work back to a person.
Consider an illustrative support workflow. Finding an approved answer, drafting a reply and changing a customer’s account are different capabilities. They need different evidence and permissions. Treating them as one vague instruction to “resolve the issue” hides the important design decisions.
NIST’s voluntary AI Risk Management Framework provides a useful foundation for considering trustworthiness across design, development, use and evaluation. Read the NIST framework.
Ask three people independently who can approve a new tool, change the acceptance threshold and pause the workflow. Conflicting answers reveal work to do before expansion.
My approach to embedded AI delivery is to connect these decisions with a working implementation. The result should be a system the business can understand, operate and improve.
Start this week by selecting one pilot and naming an accountable owner for every decision it can make.
Plan for durable capabilities, fund delivery in stages and revisit assumptions as the economics and use cases change.

A five-year AI budget should explain what the organisation intends to become capable of doing. It should also make clear which assumptions are still uncertain.
Committing to today’s model mix, usage pattern and supplier pricing for five years would create false precision. I would keep the strategic direction longer term and review the delivery portfolio and operating assumptions much more frequently.
The model bill is one component. A useful plan also includes discovery, data preparation, integration, evaluation, security, staff training, human review, support and eventual migration or retirement.
Separate initial delivery costs from recurring operation. Then give each use case an owner and an allocation method for shared infrastructure. This helps finance distinguish a successful service growing with demand from an inefficient workflow generating avoidable retries.
FinOps guidance makes a useful distinction between resource measures, such as token cost, and business measures, such as cost per case resolved. Both can help explain spending. Read the FinOps unit economics guidance.
For the first year, fund a small portfolio with explicit evidence gates. Establish a baseline, test a bounded workflow and expand only when quality, operational readiness and value justify it.
For years two and three, plan options for shared capabilities: identity, approved integrations, evaluation infrastructure and team enablement. For years four and five, state the business capabilities you want and the assumptions that would change the investment. These are planning horizons, not a prediction of how fast every company will mature.
Build conservative, expected and high-demand scenarios. Change several variables: task volume, model choice, review time, failure rate and integration maintenance. A lower inference price may be offset by more usage or more expensive review.
Time saved becomes useful when the organisation decides what to do with it. Faster turnaround, better service and reduced backlogs can all matter. They should be measured separately from cash savings.
Do not count the same hour twice across overlapping automations. Do not assume every released hour reduces payroll. Include the time spent checking and correcting the result.
At the next budget meeting, ask for a one-page investment case per workflow: baseline, full operating cost, expected benefit, uncertainty range and a date for the next decision. That is a budget leadership can steer.
Use AI capability changes to revisit specific business assumptions, with evidence from the workflow and a clear route to adoption.

An existing technology strategy can remain directionally sound while some of its delivery assumptions become outdated. AI may change how a task is performed, who reviews it and which integrations are worth building.
The useful response is a targeted review of the work. Look for assumptions that can now be tested more cheaply or challenged by a different architecture. Keep the business outcome visible throughout.
Start at the desk where the delay occurs. Ask someone to show the last difficult case, including the documents, systems and decisions involved. A polished process diagram rarely captures every workaround.
AI may help interpret unstructured material or prepare an initial draft. It cannot resolve missing authority, unclear policy or unavailable data simply by generating an answer. Sometimes the best first change is a cleaner handoff, a better interface or ordinary automation.
For each candidate, record the current constraint and the evidence that an AI component would improve it. This prevents a strategy refresh from becoming a list of tools to purchase.
An illustrative internal service might move from manual triage to assisted classification, with uncertain cases still routed to a person. The experiment should measure end-to-end handling time, misrouting, review effort and downstream impact.
Keep a simple baseline in the comparison. A rules-based route may be sufficient for common cases, while a model handles a narrower ambiguous subset. Architectural choice should follow the work and its consequences.
I would also revisit build-versus-buy assumptions. Include configuration, integration, governance and switching effort in both options. A rapid prototype is useful evidence about feasibility; it is not the full operating cost.
Give the strategy a quarterly review: which assumptions changed, which pilots produced evidence, which services are ready to expand, and which should stop? Preserve the longer-term purpose while allowing delivery choices to change.
FinOps describes technology value as a shared responsibility across engineering, finance and business teams. That collaboration is equally useful when deciding where AI belongs in a transformation portfolio. Read the FinOps framework.
My role in embedded delivery is to turn a broad ambition into a practical experiment, then connect the result to architecture and adoption decisions.
Choose one expensive handoff this week. Observe it, establish a baseline and define the smallest credible test.
Practical training helps people decide what to share, what to verify, when to act and when to stop.

A team can become fluent at prompting while remaining uncertain about the decisions that matter most. Can this document be uploaded? Is the answer supported? May the agent send the message? What should happen when the result looks plausible but feels wrong?
I would build an AI training programme around those moments. Good judgement needs realistic practice, approved tools and an accessible route to help.
Give a sales team a proposal with an unsupported claim. Give an engineering team a generated change with a subtle permission error. Give an operations team a document containing instructions that conflict with the approved workflow.
Use synthetic or appropriately sanitised examples. Ask participants to identify the evidence, the data boundary and the action they are authorised to take. Let them practise stopping and escalating, as well as completing the task.
Training should reflect each role’s access and consequences. A person drafting internal notes needs different preparation from someone approving external communications or granting an agent access to production systems.
Publish a short guide alongside the approved tool: allowed data, prohibited uses, verification steps, escalation contact and incident reporting route. Provide a sandbox where people can learn without affecting customers or live records.
Managers need training too. They decide how much time review receives and whether staff feel comfortable questioning an AI-generated result. A policy loses credibility when speed targets make its checks impractical.
The European Commission’s current AI literacy guidance describes context-sensitive measures that support staff and others operating AI on an organisation’s behalf. It does not prescribe one specific literacy level for every individual. Read the Commission’s AI literacy guidance.
Completion rates show attendance. Short practical exercises reveal whether the guidance works. Can a participant spot a disclosure risk, challenge an unsupported answer and locate the reporting route?
Repeat relevant exercises after a significant tool or workflow change. Review recurring questions with the people maintaining the system. Confusion can be evidence that the interface or policy needs improvement.
The objective is confident, responsible use. Choose three realistic decisions from one team’s daily work and build the first session around them.
Apply familiar security disciplines to the new pathways created by models, tools and retrieved content.

Connecting a model to a business system creates a new route through which information and actions can travel. That route needs an identity, a purpose and a boundary.
A confident instruction in a prompt cannot substitute for an access control enforced by the application. The model may misunderstand a task or encounter hostile instructions in material it reads. Design the surrounding system to limit what an error can affect.
Give each workflow only the data and actions needed for its job. Keep reading, drafting and committing changes as separate capabilities where the risk warrants it. Enforce authorisation at the tool or service boundary using the user’s legitimate access context.
Avoid a shared administrator credential that gives every agent the same reach. Review service identities, secrets handling and revocation paths. In an illustrative document assistant, access should follow the user’s entitlement to a document, including during retrieval and citation.
OWASP’s excessive-agency guidance highlights unnecessary functionality, permissions and autonomy as sources of risk. Read the OWASP guidance.
An external page, email or repository file can contain instructions. Those instructions are data to assess, not authority to change the workflow’s purpose or permissions.
Use layered controls: narrowly defined tools, validated parameters, restricted destinations, approval for consequential actions and useful monitoring. Test whether the system remains within its boundary when retrieved material is misleading or adversarial. No single prompt or content filter should carry the entire security argument.
Retain ordinary engineering disciplines as well: patch dependencies, review changes, protect credentials and prepare recovery procedures. The NCSC’s secure AI development guidance covers security throughout design, development, deployment and operation. Read the NCSC guidance.
A useful security review includes attempts to reach another user’s records, send data to an unapproved destination or perform an action outside the task. Record the result at the system boundary, not just the model’s verbal refusal.
Start with one agent and list every tool it can call. For each capability, identify its business need, enforced scope, owner and revocation method. Remove access that has no defensible purpose.
An approved model does not automatically make every document appropriate input. Govern the complete information path.

The question “Which AI tool may we use?” needs a companion: “Which information may this workflow send to it?”
A supplier approval is useful, but it cannot answer every question about purpose, user access or sensitivity. The same service may be appropriate for public product information and inappropriate for a confidential personnel case under the chosen configuration.
Define practical categories with examples from the organisation: public, internal, confidential and restricted. For each category, specify approved workflows and environments, required handling, and the person who can authorise an exception.
These are organisational design choices, not universal legal classifications. Involve the relevant data, privacy and security owners so the rules match actual obligations and contracts.
Reduce the material sent to what the task needs. A support draft may need a problem description and product details; it may not need an entire customer history. Redaction can help, but context and combinations of details may still identify someone or reveal confidential information.
Map the prompt, uploaded files, retrieval store, inference service, tool responses, logs, backups and generated output. Ask where each is processed and retained, who can access it and how it is deleted.
An EU storage location answers only part of this map. Inference location, support access, subprocessors and connected tools deserve separate examination. Obtain service-specific evidence rather than assuming that a regional label covers every component.
OWASP identifies sensitive-information disclosure as an application risk involving both the model and its context. Read OWASP’s sensitive-information guidance.
Put concise handling guidance beside upload and connector controls. Enforce access restrictions and destination rules where possible. Provide a route for legitimate exceptions, with an owner, documented scope and review date.
Review the outputs too. A summary can expose confidential information even when every input came from an approved repository. Retrieval permission and permission to disclose are separate decisions.
My starting deliverable would be a one-page data-flow map for a single use case. Trace a real example from entry to deletion. Any unanswered question becomes a specific architecture or supplier-review task.
Translate written rules into permissions, approval gates, evidence and exception handling that operate with the workflow.

An AI policy becomes operational when it changes what a system can do. A document saying “use responsibly” leaves too many decisions to interpretation at the moment of action.
My approach is to turn each important rule into a control with a clear owner and a way to test whether it works. The harness is where business policy meets the model’s tools, context and execution path.
Take a rule such as “external communications require an authorised reviewer.” The implementation needs a draft state, an identified reviewer, a view of the proposed message and recipients, and a send operation that remains unavailable until approval is recorded.
A spending boundary needs an enforced limit and an approval route for exceptions. A data restriction needs access and destination controls. A requirement to use approved evidence needs source checks and a clear response when evidence is missing.
These examples are design patterns, not claims that one technical control establishes legal compliance. The control set must fit the use case and its consequences.
Some legitimate work will fall outside the standard route. Record the reason, approving authority, scope and expiry of an exception. Avoid silently converting a one-off exception into permanent permission.
Treat changes to models, prompts, tools and approval logic as changes to the operating system of the workflow. Version them, test the affected cases and preserve a recovery path. The same model can behave differently when its context or tool set changes.
The NCSC’s secure AI guidance treats deployment and ongoing operation as security responsibilities alongside development. That supports maintaining controls after launch. Read the NCSC guidance.
Staff need approved ways to complete their work and a safe route to report errors. Deliberate bypassing of controls should enter an established, proportionate process developed with HR, legal specialists and employee representatives where applicable. Do not improvise automatic penalties from an AI alert.
Investigate what happened, whether the rule was clear, and whether the system made safe behaviour practical. Technical containment and an employment decision serve different purposes.
Choose one policy statement this week. Identify its enforcement point, responsible owner, exception route and test. If none exists, the next task is implementation.
A review step is useful when the person can understand the evidence, challenge the recommendation and change what happens next.

“A human will check it” can sound reassuring while concealing an unfinished design. Who is that person? What will they see? How much time do they have? Can they reject the proposed action without fighting the system?
I treat oversight as part of the workflow architecture. It needs a defined purpose and enough support to make a decision worthwhile.
A low-consequence internal draft and a consequential customer decision need different review arrangements. Decide which outputs need review, what triggers escalation and which actions should remain outside the agent’s authority.
The reviewer should see the proposed action, relevant evidence, material uncertainty and the changes the action would make. A generated explanation is not automatically proof that the underlying reasoning or sources are correct. Show the actual supporting records where access and confidentiality allow it.
For an illustrative account update, the review could show the current value, proposed value, source record and affected downstream process. A generic “approve” button provides less useful context.
Train people on the specific failure modes they are expected to catch. Protect time for review and provide a route to specialist help. Let reviewers pause, reject or return work with a reason that can improve the system.
Measure review load as the service grows. If automation creates more cases than the team can meaningfully inspect, the original oversight design no longer matches the operation. Change the scope, capacity or controls before treating rushed approvals as evidence of safety.
NIST’s Generative AI Profile discusses risks including problematic human-AI configurations and provides risk-management actions for organisations. Read the NIST Generative AI Profile.
Use representative exercises to check whether reviewers detect relevant errors and understand when to escalate. Inspect false alarms too: an exhausting stream of low-value warnings can undermine attention.
Record the decision and enough context for accountability, with appropriate limits on sensitive logging. Review recurring rejection reasons with engineering and the process owner.
For the next pilot, write a short reviewer brief before building the approval screen. Specify the evidence, expected decision, available actions and escalation route. Then test it with the people who will use it.
Plan how to contain an agent, preserve useful evidence, restore service and learn from mistakes before an incident occurs.

Imagine an agent starts sending an incorrect update to a connected system. The model’s answer is only one part of the incident. You also need to know which actions completed, which are pending and what customers or colleagues may now rely on.
A response plan should answer those questions before the team is under pressure. The exercise can start small, with a synthetic scenario and the actual people who would respond.
Identify who can suspend the workflow, revoke its credentials or disable a specific connector. Test those controls. A pause in the user interface may not stop queued jobs or actions already accepted by another service.
Decide how essential work continues while the system is unavailable. That might mean a manual route, a restricted read-only mode or a previous version. Check that the fallback can handle realistic demand.
Preserve relevant evidence with appropriate access and retention controls: affected records, action identifiers, configuration versions and timestamps. Avoid collecting entire sensitive prompts by default when a narrower record would answer the incident question.
Staff should know where to report an unexpected result or accidental disclosure. A useful first report can be incomplete. The response team can establish scope as evidence arrives.
The NCSC’s security culture guidance emphasises accessible reporting, fair treatment and learning from incidents. People need confidence that raising an innocent mistake will help the organisation respond. Read the NCSC security culture guidance.
Avoid the lazy assumption that every failure is a careless employee. Examine permissions, interface design, training, workload and the incentives surrounding the decision.
Restoring technical service does not automatically establish that the workflow is ready to resume. Identify the failure mode, correct the relevant controls and rerun the cases that matter. Assign a named owner to the restart decision.
Involve security, privacy, legal and business owners as appropriate to assess notification or other obligations for the actual incident. A generic AI playbook cannot determine every applicable deadline or duty.
Run a short tabletop exercise this month: one wrong action, one exposure of information and one supplier outage. Finish with assigned improvements and a date to retest them.
Use a compact view of value, reliability, control and adoption to decide which AI services to expand, improve or retire.

Leadership needs a way to see whether AI is improving the business and whether the organisation can control it. A count of licences, experiments or generated tokens answers only a small part of that question.
I would use a compact scorecard for each important workflow, with a named business owner and a regular decision meeting. Keep the measures understandable and connected to an action.
Start with the accepted business outcome: a completed case, a reviewed change or a useful customer response. Compare the end-to-end result with an agreed baseline, including review and rework.
Show total operating cost with its main drivers, alongside the cost per accepted outcome. Separate released capacity, service improvements and verified cash savings. Record the assumptions so a change in volume or case complexity does not masquerade as improved performance.
Keep a view of the cases where the workflow does poorly. A healthy average can hide unacceptable results for a particular group, input type or exception path.
Useful questions include: Are permissions current? Have consequential action boundaries been tested? Can the service be paused? Are evaluation results still representative? Are unresolved incidents or expired exceptions accumulating?
Keep the evidence behind each answer accessible. A green status chosen by intuition is less useful than a dated test, a named owner and a clear acceptance criterion.
NIST’s voluntary AI Risk Management Framework supports integrating risk management into the design, use and evaluation of AI systems. A leadership scorecard can make selected responsibilities visible in regular operating decisions. Read the NIST framework.
For each service, choose an action: expand, maintain, improve, restrict, pause or retire. Assign the next piece of evidence and the person responsible for it. Review adoption and staff feedback alongside technical measures; an unused tool may have a workflow problem that another model will not solve.
I would start with four areas: business value, reliability, control and adoption. Choose a few meaningful measures in each, with thresholds appropriate to the use case. Avoid combining everything into a single reassuring score that hides a critical failure.
The goal is a leadership rhythm that connects strategy to operational reality. Bring one live AI workflow to the next management meeting and ask what evidence would justify its next stage.
Power becomes useful when the surrounding system gives it direction, boundaries and feedback.

A powerful AI model reminds me of a stallion: capable of extraordinary work, but buying the horse does not give you a transport system. You still need direction, a suitable harness and someone responsible for the journey.
The analogy has limits. Software is not an animal, and no harness makes a language model perfectly predictable. But it captures a mistake I want more business leaders to recognise: choosing a model and writing a prompt are only part of building an operational system.
I use “model harness” to mean the surrounding software that supplies context, exposes tools, manages the work and checks what happens. An agent harness gives the model a controlled way to take steps. An evaluation harness tests whether the combined system behaves as intended. These are related responsibilities, not interchangeable labels.
Imagine a customer-support assistant. A prompt can ask it to be helpful. The harness decides which customer records it can read, which policy version applies, whether it can draft or send a message, and what must happen when the account cannot be identified. Those decisions determine whether helpful language becomes useful work.
My starting design has six parts. A clear task contract defines the requested result. A context boundary supplies relevant evidence. A tool boundary limits possible actions. Persistent state records progress. Verification checks facts and outcomes. A stopping rule decides when to finish, retry or ask a person.
Some controls should be ordinary software. A permission check belongs in the tool or service, not only in a sentence asking the model to behave. A database constraint should not depend on how confident a generated answer sounds. A human approval should authorise a specific action and its current parameters.
The goal is consistent standards, not identical prose. Two acceptable summaries may use different words. Two attempts to update a customer record must respect the same access rules and business constraints. When the system cannot meet those standards, an explicit exception is more useful than a polished guess.
Anthropic’s work on long-running agents provides a practical example: explicit setup, bounded increments and durable handover artifacts help work continue across sessions. Anthropic — Effective harnesses for long-running agents The wider lesson I draw is that continuity and verification deserve engineering attention alongside model capability.
This is the work I enjoy: meeting the operational problem, understanding what good looks like, and building a system around the model that can earn trust through evidence. The model provides capability. The harness helps turn it into a service a business can actually operate.
Need to turn a promising AI demo into a controlled workflow? Let’s discuss the harness at hi@fdo.codes.
An embedded approach finds the real work, its exceptions and the people who must trust the result.

The most useful place to begin an AI project is often beside the person doing the work. Watch a task move between an inbox, a spreadsheet, a business application and a conversation with a colleague. Ask where it slows down. Ask what happens when the normal process breaks.
This is the forward-deployed style of engineering I want to bring to clients: stay close enough to understand the operational problem, then take responsibility for translating it into a working system. It combines discovery, architecture, implementation and adoption in one continuous conversation.
A workshop might describe the process as “prepare a project update.” At the desk, someone is resolving conflicting task statuses, chasing an owner, deciding which delay matters, and rewriting the update for different audiences. Generating a paragraph solves only a small part of that job.
I would begin with a concrete work sample and trace it from request to completion. Which information was available? Which judgement required experience? Which systems were touched? What made the result acceptable? What happened to the exception that nobody put in the process diagram?
Then I separate the steps. Some need a better form or integration. Some are deterministic transformations. Some benefit from retrieval or language understanding. Only a few may require an agent to decide what to do next. This avoids putting model calls into steps that ordinary software can already handle clearly.
The first useful deliverable is a shared problem definition: who owns the work, what outcome matters, the current baseline, the permitted data, and the cost of getting it wrong. That gives the team a way to judge a pilot beyond whether the demonstration looks impressive.
For an illustrative project-update assistant, I might start with read-only access, a draft grounded in linked task records, visible unresolved questions and a manager’s approval before circulation. The pilot would measure time to an accepted update, missing facts, correction effort and usage. This is a proposed pattern, not a claim about a named client deployment.
Working alongside people also reveals adoption constraints. An elegant separate application may create another place to check. A smaller change inside the existing workflow may be more useful. The right delivery includes training, ownership, a support route and a way to recover when the system is unavailable.
I bring software delivery, IT leadership and product experience to that conversation. My role is to connect business pain with the architecture and engineering needed to change it. I want a client to leave with a working capability and people who can operate it, with a clear handover that lets the team continue improving it.
For discovery and delivery alongside your team, explore Embedded AI Delivery at fdo.codes.
A European storage location is one part of the architecture, not a complete answer about processing.

“Our data is in Europe” sounds reassuring. Before approving an AI pipeline, I would ask what that statement covers. The application database, model processing, embeddings, uploaded files, backups, logs, support access and external tools can follow different paths.
Data residency commonly describes where specified data is stored. Inference location describes where the model processes a request. Providers may package these commitments together, but the exact product, deployment type, feature and contract matter. A resource created in an EU region does not, by itself, establish the location of every processing step.
Microsoft’s current documentation makes this distinction explicit for Foundry Models sold by Azure. Global deployments can process prompts and responses across supported geographies, while EU DataZone deployments constrain that processing to EU member nations. Specified stored data remains in the customer-designated geography for both types. These are deployment-specific statements, not a promise about every service carrying the Microsoft name. Microsoft — Data, privacy and security for Foundry Models sold by Azure
AWS likewise distinguishes geographic inference routing from global routing. Its geographic cross-Region documentation notes that prompts and results can leave the source region while remaining inside the selected geography. It also describes model-dependent abuse-detection storage in a destination region. An EU geography is therefore different from a promise to stay in one EU country. AWS — Geographic cross-Region inference
My engineering review starts with a data-flow map. For every component, I record what enters it, where processing occurs, what is retained, who can access it and how deletion works. I include the less visible components: a tracing service, a document parser, a search API and an agent’s browser tool. A correctly configured model endpoint cannot govern a separate tool’s data handling.
Location is also distinct from training use, retention, encryption and control of encryption keys. “Not used to train” does not mean “never stored.” “EU-hosted” does not automatically mean compliance. These questions need separate answers.
The EDPB’s transfer guidance illustrates another distinction: remote access by a separate processor in a third country can be an international transfer even when data stays stored in the EU. It separately explains why access by an employee of the same controller is not automatically such a transfer. EDPB — Guidelines 05/2021, final version, examples 8 and 11 GDPR also provides mechanisms for lawful transfers; it is not a blanket EU-only hosting rule. EDPB — Standard contractual clauses
I would bring this map to the organisation’s privacy and security owners before a production commitment. Their assessment may include lawful basis, minimisation, contracts, transfer arrangements and any required impact assessment. My contribution is to make the technical facts and viable architecture choices clear enough for that decision.
This work can unblock a pipeline. A vague objection about “European data” becomes a precise requirement: these data classes, these permitted regions, these tools and these retention rules. Then the team can compare real options, including availability, performance and operating cost.
I help teams map AI deployment boundaries and compare workable architectures with their privacy and security owners. hi@fdo.codes
Token prices matter. Retries, review effort and failed work determine whether the system is economical.

When an AI pipeline looks expensive, the first reaction is often to choose a cheaper model. Sometimes that helps. Sometimes it shifts the bill into retries, manual correction and support. I want the business to see the cost of completing useful work, including the cases that go wrong.
My preferred unit is cost per accepted outcome. For a defined workload, add model usage, tools, infrastructure, review effort and operating support, then divide by outcomes that meet the acceptance standard. Keep one-off development investment visible separately or amortise it explicitly. Do not hide it in a mysteriously low operating number.
Consider a deliberately simplified illustration. A batch costs €12 in model and tool usage and €48 in review time. If 80 outcomes are accepted, that is €0.75 per accepted outcome. A second design costs €20 in usage and €20 in review, with the same accepted volume: €0.50. These are invented teaching numbers, not provider prices or client results. They show why the cheapest inference can produce the more expensive service.
The harness gives us places to improve. Repeated full-document reads, oversized tool results, unnecessary model turns and loops without a useful stopping condition are candidates for investigation. A trace should reveal which step consumed the budget and whether that step improved the result.
Context engineering means choosing relevant information rather than accumulating everything available. Anthropic’s guidance describes context as a resource to curate throughout an agent’s run. Anthropic — Effective context engineering for AI agents Its tool-use work also shows why discovering tools when needed and processing intermediate results outside the model can reduce avoidable context load. Anthropic — Introducing advanced tool use Neither technique should be adopted without checking its effect on the actual workload.
For a proposed support workflow, I would retrieve the relevant policy section, keep a reference to the source, and perform straightforward lookups in code. I would test whether a smaller model handles classification, while reserving more capable inference for cases that need it. The escalation rule would come from observed performance, not the model’s self-reported confidence alone.
Hard budgets matter. Limit steps, elapsed time, tool calls and spend per run. When a case reaches its limit, stop with a useful handover containing what was tried and what remains unresolved. An agent repeatedly attempting the same action is generating activity, not necessarily value.
Finally, look at the distribution. An attractive average can conceal a small group of extremely expensive cases. Track the tail, review workload, unsuccessful runs and latency alongside quality. The business decision is whether this complete service improves the work at an acceptable cost. Token optimisation earns its place when that answer becomes stronger.
For a practical review of workflow quality, cost and bottlenecks, contact hi@fdo.codes.
An illustrative onboarding pipeline shows where model judgement helps—and where ordinary software should decide.

“Give an agent access to our systems and let it help” is an incomplete brief. Before connecting tools, I want a specific job, a permitted action set and a visible definition of completion. A narrower starting point makes it easier to evaluate whether autonomy adds value.
Consider an illustrative employee-onboarding assistant. Its job is to prepare a checklist from an approved role template and information supplied by HR. It should identify missing inputs, assemble the relevant tasks and draft requests for responsible teams. This is a design proposal, not a description of a confidential deployment.
The pipeline begins with ordinary checks: validate the request, confirm the requester’s permissions and select the approved template version. The model can interpret unstructured notes or explain a missing requirement. It should not invent an employee’s role, approve its own access request or decide that a mandatory security step is inconvenient.
I would keep draft creation separate from execution. The harness presents the proposed checklist with evidence, changes and unresolved questions. Approved actions then pass through a service that rechecks authorisation and parameters. For access provisioning, the identity system and designated approver remain the authority.
Tools should reflect that separation. “Read approved role template” and “prepare access request” are easier to reason about than a general administrator shell. OWASP’s excessive-agency guidance identifies overly broad functionality, permissions and autonomy as important sources of risk. OWASP — Excessive Agency Applying the boundary outside the prompt makes it harder for an unexpected model response to become an unauthorised action.
External text also needs a clear status. An attachment or retrieved page is evidence to interpret, not an instruction source allowed to rewrite the workflow. Prompt injection requires layered defences; instructions telling the model to ignore attacks are not a complete control. OWASP — LLM Prompt Injection Prevention
Operational reliability adds another layer. A timeout must not create the same task twice. An interrupted run needs enough durable state to resume sensibly. I would use stable operation identifiers, verify external outcomes and keep a recoverable record of completed steps. Persistence frameworks support checkpoints, but the application still needs to design its side effects and permissions. LangGraph — Persistence
The acceptance test follows the work: correct checklist, valid sources, missing information flagged, no unauthorised account changes, and no duplicated requests after retry. Completion is the verified state of the process, not an agent saying “done.”
Concrete use cases turn agentic architecture from a diagram into decisions a client can inspect. We can expand the action boundary later if evidence shows the system and the operating team are ready. That creates a useful path from a modest first capability to a more capable service, with a clear basis for every increase in autonomy.
Model Harness Engineering turns use cases like this into explicit tools, controls, evaluations and recovery paths. fdo.codes
Evaluate outcomes, exceptions and actions across repeated runs before expanding autonomy.

Two AI answers can be worded differently and both be correct. Two identical answers can both be wrong. That is why I would not sell “uniform results every time” as the promise of a model harness. I would define a standard the system must meet and measure how consistently it meets it.
The standard depends on the job. A meeting-summary tool must represent decisions accurately and distinguish agreed actions from suggestions. A support assistant must use the applicable policy and avoid unsupported commitments. A coding agent must produce a change that works in the target environment without breaking required behaviour.
An evaluation set should contain ordinary work and the cases people find difficult. For an illustrative meeting-to-action pipeline, I would include contradictory statements, a changed deadline, an absent owner, a cancelled task and a transcript containing instructions aimed at the agent. The expected behaviour may be a correct result, an explicit uncertainty or a decision to ask a person.
I would test representative cases multiple times. One successful demonstration is weak evidence about a probabilistic system. Anthropic’s evaluation guidance separates a task from an individual trial and distinguishes the agent’s transcript from the actual outcome in its environment. Anthropic — Demystifying evals for AI agents That matters whenever the system can act: claiming a task was created is different from a verified task in the right project.
My evaluation plan would combine several checks. Code can verify a required schema, permitted identifiers and observable system state. Human reviewers can judge usefulness against a written rubric. Model-based grading can help at scale, but needs calibration against human judgement; another model is not an infallible judge.
Agree the release threshold before examining the latest results. Which errors are tolerable? Which actions are prohibited? How often may the system escalate? What latency and review burden can the team accept? There is no universal percentage that answers these questions for every workflow.
Test the harness as well as the answer. Did the run respect tool permissions? Did it stay within its budget? Did it preserve evidence for review? Did a failed dependency trigger a useful fallback? A fluent final paragraph can conceal a poor execution path.
After release, sample real outcomes and maintain a regression set of meaningful failures. Refresh cases as the work changes. Preserve a held-out set where possible so the team does not merely optimise for familiar examples.
The client should see the system’s strengths and limits in terms of their work. That is a useful form of confidence: success is testable, failure is visible, and the team knows what to do when a case falls outside the expected boundary.
I help teams define acceptance criteria and build evaluations into the delivery workflow. hi@fdo.codes
Repository context, bounded tasks and release evidence matter as much as code generation speed.

Generating code is one part of delivering software. A client still needs a useful product, a maintainable codebase and confidence that a release does what it is supposed to do. My interest in agentic coding is the complete delivery pipeline around the agent.
My current team uses an agentic coding workflow I created. The broader service I want to bring to clients is a repeatable engineering approach that helps teams build with agents while keeping architecture, review and delivery ownership clear. The workflow must fit the product and the team; installing the same tool everywhere is not enough.
For a new engagement, I would first make the repository legible. The agent needs a reliable way to understand the architecture, run relevant checks, locate the part it should change and identify constraints. Instructions should be short enough to use, specific enough to matter and maintained alongside the code.
Then I would define a bounded unit of work. “Build the whole platform” leaves too many decisions implicit. “Implement this user journey, with these acceptance criteria and these existing interfaces” gives both the agent and reviewer something concrete to assess. The task should identify decisions that belong to a person.
Long-running work needs continuity. Anthropic’s harness experiments use explicit progress artifacts and incremental work to address loss of context between sessions. Anthropic — Effective harnesses for long-running agents Its later application-development work also examines separate generation and evaluation responsibilities. Anthropic — Harness design for long-running application development I treat these as patterns to test, not a requirement to add more agents to every repository.
My proposed flow is simple: clarify the change, prepare the context, implement a small slice, run meaningful checks, review the diff, verify the user journey, and release through the team’s normal controls. A test result is evidence for a particular behaviour; it does not replace understanding the change.
Where several teams contribute, shared contracts become especially important. Service interfaces, ownership, migration rules and review responsibilities prevent one fast agent from creating work for three other teams. Parallel implementation helps only when changes can be integrated and operated coherently.
I would measure time to an accepted change, escaped defects, review effort and rework. Lines generated and prompts submitted are activity measures. They do not tell a product owner whether delivery improved.
Agents can give a small team more implementation capacity. The harness should convert that capacity into useful releases without quietly accumulating confusion. That includes a handover: documented decisions, a known support path and a team that can change the system after the original builder leaves. Good agentic delivery should increase the team’s capability, not make the codebase understandable only to whoever wrote the first prompt.
AI Engineering Enablement helps development teams establish shared agentic coding and review practices. fdo.codes
Parallelism is useful when the work separates cleanly and the coordination cost is justified.

A diagram with six agents can make a proposal look sophisticated. It can also represent six opportunities to repeat context, disagree, retry and lose ownership. Before adding another agent, I want to know what distinct responsibility it improves and how we will measure the improvement.
The first question concerns the structure of the work. If the next step is known, a fixed workflow may be easier to test. If the next step depends on what the system discovers, an agent may be useful. Anthropic’s design guidance makes this distinction and recommends starting with simple, composable patterns. Anthropic — Building effective agents
Take an illustrative research brief assembled from approved internal sources. Parallel workers could independently inspect separate source collections and return evidence. A coordinator could combine those findings into a draft. That can be a sensible division because source reviews are separable and the output contract can be explicit.
Now imagine every worker receiving the full company knowledge base, searching the same documents and reviewing every other worker indefinitely. The names “researcher,” “critic” and “manager” do not make that efficient. Without boundaries, the pipeline can spend its budget discussing work rather than completing it.
I would give each worker a narrow scope, an input contract, an output format, a source requirement and a budget. The coordinator should know what counts as a missing result, when to retry and when to continue with a visible limitation. Shared state needs an owner; competing writes need coordination outside a natural-language conversation.
An evaluator is useful when its criteria are specific enough to change a decision. Asking another model “does this look good?” can add confidence without adding evidence. For a research brief, checks might concern source coverage, unsupported claims, contradictions and whether the requested questions were answered. A person may still need to assess relevance to the business decision.
To choose the architecture, I would compare a single-agent baseline with the proposed multi-agent design on the same cases. Track accepted outcomes, elapsed time, total tokens, tool charges and review burden. Include failures and integration work. A speed improvement is less compelling if it creates more correction effort.
There are good reasons to use multiple agents: independent investigation, distinct tool environments, parallel implementation with clear ownership, or specialised evaluation. There are equally practical reasons to keep one agent inside a straightforward workflow.
My aim is a system the client can understand and maintain. Every additional agent should have a job that is necessary, bounded and observable. Architecture becomes more convincing when the team can explain what would get worse if that component were removed—and can show evidence that the added coordination is worthwhile.
For a review of agent architecture and workflow complexity, contact hi@fdo.codes.
Agentic development can accelerate learning when the product slice and production gap are explicit.

A startup does not need every feature to discover whether an idea is useful. It needs the smallest credible experience that lets the right people test the most important assumption. AI coding pipelines can help build that experience, provided the team is clear about what it is trying to learn.
I would start with one sentence: “We believe this user will use this capability to achieve this result.” Then I would ask what evidence would change our minds. That gives the prototype a purpose beyond demonstrating that we can generate an interface quickly.
Consider an illustrative project-management assistant that turns a meeting into a draft action list. The first slice could accept a sample transcript, propose owners and deadlines, and let a user correct the result before anything is written to a live project. The product question is whether that review experience saves useful effort and preserves trust.
That is enough to test several assumptions. Can users recognise unsupported suggestions? Do they want a separate tool or an integration? Is the action list valuable, or is the real pain following up a week later? Building a large autonomous planning system first could automate the wrong experience.
My proposed prototype pipeline connects a short brief, a small architecture decision, agent-assisted implementation and a repeatable demonstration. Human review remains responsible for product behaviour and the change. Test data should be suitable for the environment; a prototype is not permission to copy sensitive production data wherever the tools happen to run.
Speed also requires an honest label. A visual prototype, functional pilot and production service are different deliverables. A polished screen does not establish access control, resilience, supportability or sustainable operating cost. I would make the production gap visible before a client decides to scale.
The next investment should follow evidence. If the pilot is useful, extend deliberately: authentication, permissions, integrations, telemetry, failure handling, deployment and ownership. Keep the useful product slice working while making those foundations stronger. If the idea is weak, preserve the learning and stop before a larger build makes it emotionally harder to change direction.
For founders, I offer product and technical judgement alongside implementation. For development teams, I can establish the agentic workflow that turns a validated slice into a maintainable product. The aim is a shorter route to an informed market decision, with a credible path from prototype to the system customers will rely on.
That route can be fast without promising an arbitrary launch date before understanding the scope. Speed comes from choosing the right slice, shortening feedback loops and avoiding work that does not answer the current question.
Startup Prototype & Pilot combines a focused build with a clear validation and production decision. hi@fdo.codes
Keep interfaces stable, measure changes and retire controls that no longer help.

A harness is never finished simply because the first model integration works. The model changes, the business changes, APIs change and users discover cases absent from the original brief. I want the client to inherit a system that can improve through a controlled process.
First, make current behaviour identifiable. Record the model and configuration, prompt version, tool contracts, relevant data sources and release version. A report that “the AI feels different” becomes easier to investigate when the team can connect it to a specific change.
Second, preserve a meaningful comparison. Before adopting a new model or changing the workflow, run representative cases against existing and proposed versions. Compare quality, cost, latency, escalation and action correctness. Keep difficult cases visible; averages can conceal the failure that matters to an operator.
Model improvements can make an old workaround unnecessary. They can also open a capability the architecture cannot yet use. Anthropic’s managed-agents work discusses assumptions in harnesses becoming stale, while its application-development research recommends re-examining the harness as models improve. Anthropic — Scaling Managed Agents Anthropic — Harness design for long-running application development
My interpretation is that addition and removal should both require evidence. Do not preserve a complicated routing layer merely because it was expensive to build. Do not remove a permission boundary because the latest model appears more trustworthy. A workaround for model behaviour and a business control serve different purposes.
I would separate stable interfaces from components expected to evolve. Business rules, approved actions and the definition of a completed task need clear owners. Model adapters, retrieval settings and implementation strategies can change behind those contracts when evaluation supports the change.
Continuous improvement also needs a release path. Propose a change, test it, review the evidence, deploy to a limited scope where appropriate, and monitor real outcomes. Keep a route back to the known version. “The agent improves itself” is not enough information for a person responsible for the service.
The operating team needs useful signals rather than an ocean of logs. Which cases consume the most review? Where does retrieval fail? Which tool is unavailable? Which fallback is used? Store necessary evidence with appropriate access and retention, especially when prompts or traces can contain personal or confidential information.
Finally, agree who owns the harness after launch. Someone must maintain tools, review failures, update evaluation cases and decide when a new version is ready. This is part of the product, not administration to add later.
The long-term value of embedded AI delivery is a working capability the organisation can understand, measure and evolve. A good handover lets the team keep improving the system without starting the conversation from zero every time the model changes.
Embedded AI Delivery includes the architecture, operating model and handover needed beyond the first release. fdo.codes
An agent is a language model, a set of tools and a loop. Where that combination pays off in real organisations, and where a plain workflow is still the better choice.

“Agent” has become one of the most stretched words in technology. It gets attached to chatbots, scripts with a model call inside, and genuinely autonomous systems alike. That makes it hard to decide where agents belong in an organisation, and easy to build one where something simpler would do better.
Here is the definition I work with: an agent is a language model, a set of tools and a loop. The model looks at the goal and what it knows so far, decides on the next step, calls a tool, reads the result and repeats until the job is done or it hands over to a person. Everything else (memory, planning, multiple agents talking to each other) builds on that loop.
The first question is not which agent to build, but whether you need one at all.
If you can draw the steps in advance, build a workflow: a fixed sequence where a model handles specific steps, such as reading a document or classifying a request, and ordinary code handles the rest. Workflows are predictable, cheap to run and easy to test.
Reach for an agent when the path depends on what you find along the way. Investigating an incident, chasing down why two records don’t match or assembling context from several systems are hard to script, because the next step depends on the last result.
In practice, most production systems I build are workflows with agentic pockets: a deterministic backbone, with an agent handling the steps that genuinely need judgement.
The strongest use cases I see share three traits: high volume, messy inputs and a clear definition of a good outcome.
Notice that none of these remove the human. They change where the human spends their attention.
When an agent misbehaves, the model is rarely the root cause. These usually are:
“Human in the loop” is often added at the end as a safety blanket. It works better when it is designed in from the start, at the points where judgement or accountability actually sits:
The goal is not to remove people. It is to move them to the decisions that need them.
AI coding agents now write much of the code on my client builds. The pattern is the same as in any agentic system: the agent handles volume, and I own the framing, the architecture, the review and the final engineering call. The agent is fast; the direction still has to come from someone who understands the problem and is accountable for the result.
If you can answer all six, an agent is very likely worth building. If you can’t, the gaps are where the project would have stalled anyway.
New models arrive every few weeks. The leaderboard rarely decides what works in production; your tasks, your data and your constraints do.

A new language model is released every few weeks, each one topping some leaderboard. It is tempting to treat model choice as the main decision in an AI project and to switch every time the rankings move.
In my experience, the leaderboard rarely decides what works in production. Your tasks, your data and your constraints do. The model is one component of the system, and the system is what has to deliver.
The major providers offer families of models in roughly three tiers, and they are worth thinking about separately:
Anthropic’s Claude models, for example, come as Opus, Sonnet and Haiku; OpenAI and Google offer similar ranges. Alongside them sit open-weight families such as Llama, Mistral and Qwen, which you can host yourself.
Good systems often use several tiers at once: a small model triages and routes, and a larger one handles the cases that need real reasoning. Matching the model to the step usually saves more money than any discount negotiation.
Public benchmarks measure general ability. They tell you little about how a model handles your documents, your terminology and your edge cases.
What works is a small evaluation set built from real examples:
An afternoon of evaluation beats a week of reading release notes.
Once that set exists, deciding whether to adopt a new model takes hours instead of weeks of debate.
When I compare models for a production system, these are the questions that matter:
Hosted frontier models give you the most capability with the least operational effort. Open-weight models give you control: data never leaves your infrastructure, you can fine-tune, and costs are predictable at scale.
The trade-off is operational effort and, for the hardest tasks, usually some capability. A common and sensible split is hosted models for complex reasoning and open-weight models for high-volume or particularly sensitive steps.
The one thing I can predict is that today’s best choice will not be next year’s. So I build systems where switching models is a configuration change followed by an evaluation run, not a rewrite:
With that in place, a new release becomes an opportunity rather than a migration project.
My default is to start each step with a strong mid-tier model, measure it on real cases, then move the hardest steps up a tier and the high-volume, simple steps down. I re-run the evaluations whenever a significant new model arrives, and only switch when the numbers say so.
The model matters. But the evaluation set, the tool design and the guardrails around it are what turn a good model into a system people can rely on.
The four stages I use to turn an AI idea into a system people rely on, and the question each stage has to answer before the next one starts.

Most AI projects that stall don’t fail because of the model. They fail at the edges: a problem that was never sharply defined, no way to tell whether the system is better than what it replaces, or nobody owning it after launch.
To avoid those failures, I take every AI initiative through four stages: frame, orchestrate, evaluate and ship. Each stage ends with a question that has to be answered before the next one starts. Skipping a stage doesn’t save time; it just moves the cost to later, when it is more expensive.
Start with the business problem, not the technology. The questions at this stage:
The output is a short brief: the problem, the metric, the baseline, the boundaries and the owner. If that brief can’t be written, the project isn’t ready for a design.
Exit question: do we agree on what success looks like, and how we’ll know?
Now design how it works. This is where the architecture decisions are made:
AI agents are part of how I build these systems too. Coding agents turn the design into working software quickly, while I direct the process, set the architecture and review what they produce.
The output is a working prototype running on real data, not a slide deck.
Exit question: does it work on real cases, end to end?
This is the stage most often skipped, and the one that decides whether a system can be trusted.
Agree the release criteria up front: the quality level, the failure types that are acceptable and the ones that are not.
Exit question: do we have evidence that it is better than what we do today?
Shipping is not the finish line. It is the start of the stage in which the system has to keep earning its place.
Exit question: is it being used, and is it still delivering the number we framed?
One of the systems I led replaced a transaction verification process that used to run as a manual exercise once a year.
Framing made clear what “verified” actually meant, and which mismatches genuinely needed a person to look at them. Orchestration turned the matching into an automated workflow, with the exceptions routed to the right people along with the context they needed. Evaluation compared its results with the outcomes of the manual process before anyone relied on it. And once shipped, it ran continuously instead of once a year, so problems surfaced while they could still be acted on.
None of those steps depended on a particular model. They depended on being clear about the problem, the measure and who decides.
Each stage answers a different question: should we build this, does it work, can we trust it, and is it still working? The technology changes every few months. Those questions don’t.
Domain bought, backend built, fully hosted. From idea to production in sixty minutes. Imagine what one hour could do for your business.
I approach AI leadership as responsibility for the whole solution:
My focus is on building organisations’ ability to deliver with AI, and turning that ability into working systems and products.
An AI-supported risk system that uses historical assurance data to help teams identify participants and audits requiring closer attention.
An agent-driven workflow that classifies, prioritises and routes reports of sustainability incidents, helping assurance teams focus their response.
An automated reconciliation workflow that reduced a previously annual manual cycle to near real time.
An AI-supported tool that flags potentially manipulated or forged documents for further review.
An Ayurvedic self-care application developed for an external client across Android, iOS and backend, using AI coding agents under my direction.
A dating and community app for the spiritual and yoga community. In development for an external client through an agentic workflow.
A community and social-app project connecting people interested in spirituality and personal development, using an AI-assisted product-development approach.