RichardHam.co.uk Blog

Tag: AI

  • Building a Secure Agent Control Plane With Observability From Day One

    Building a Secure Agent Control Plane With Observability From Day One

    AI agents are being connected to real business systems at pace. Email inboxes. CRM records. Finance platforms. Document stores. In many organisations, agents now read, write, and decide across these systems — not as a pilot, but as operational infrastructure.

    The problem is that the operational infrastructure around those agents has not kept pace. Teams connect agents to sensitive systems the same way they would connect a chatbot: authenticate, test, deploy. There is no logging layer, no approval gate, no cost tracking, no failure recovery. The agent works until it does not, and when it breaks, nobody knows why.

    The agents themselves are often well-designed. The prompts are thoughtful. The integrations function. But there is no control plane — no layer between the agent and the systems it touches that handles authorisation, logging, rate limiting, approval, and monitoring. Without one, you are running production workloads with no operations team.

    What an Agent Control Plane Actually Is

    An agent control plane is the operational layer that sits between your AI agents and the systems they interact with. It is not a single tool. It is a set of components that collectively ensure agents act safely, their actions are visible, and failures are recoverable.

    Think of it the way you would think about any production system. A web application has authentication, logging, rate limiting, monitoring, and alerting. A database has access controls, backup procedures, and performance monitoring. An agent that reads client records, sends emails, and updates financial data needs the same — arguably more, because its behaviour is less deterministic than a traditional application.

    The control plane answers a set of questions that every production system must answer: Who is allowed to do what? What actually happened? How much did it cost? What do we do when it fails? And can we prove all of this to an auditor, a regulator, or a board?

    The Six Components You Need

    Authentication broker. Agents need credentials to access systems, but those credentials should not live inside the agent or its prompt. A central broker issues scoped, time-limited tokens with minimum permissions. When the token expires, access stops. This is service account management applied to agents.

    Audit logger. Every agent action must be logged in a structured, tamper-evident format. Not just the final output — the full chain: what the agent was asked, which tools it called, what decisions it made, what it executed, and what it returned. Teams log the input and output but miss the intermediate steps. When an agent takes an unexpected action, you need to trace the reasoning that led to it.

    Approval workflow. Not every action should be autonomous. A control plane defines which actions require human approval before execution. Sending an internal summary might be automated. Sending a client-facing email or modifying a financial record should require sign-off. The approval gate sits in the control plane, not in the agent’s prompt — a prompt is a request, not an enforcement mechanism.

    Observability. Tools like Langfuse are designed for this. Observability for agents means tracking execution traces, token usage, latency, error rates, and cost per execution. It means answering questions like: which workflow failed most often last week? Which agent is consuming the most tokens? Is the error rate increasing?

    Cost tracking. Agentic AI is not free. Every model call, every tool invocation, every token consumed has a cost. Without cost tracking per agent, per workflow, and per execution, you cannot budget, optimise, or identify waste.

    Failure recovery. Agents fail. Models time out. APIs return errors. A control plane defines what happens: does it retry? Escalate to a human? Roll back? Without explicit failure recovery, a failed agent either silently drops the task or retries indefinitely, burning tokens and creating duplicate actions.

    A Concrete Example

    Consider an n8n workflow that processes incoming client data: it reads a form submission, enriches the record with data from an external API, updates the CRM, and sends a confirmation email.

    Without a control plane, this workflow runs with a static API key, no logging beyond n8n’s default execution history, no approval gate for the email send, and no cost tracking. If the CRM API returns an error, the workflow fails silently. If the agent sends a confirmation email to the wrong address because the form data was malformed, there is no record of what data it saw or why it made that decision.

    With a control plane, the same workflow runs with a scoped token from the authentication broker, full execution tracing through Langfuse, an approval gate that holds the email send when the confidence score is below a threshold, and automatic retry with escalation on failure. Every execution is logged with its full decision chain. Cost per execution is tracked and surfaced on a dashboard.

    The workflow is the same. The operational posture is completely different.

    Why From Day One Matters

    Retrofitting observability and security into a live system is significantly more expensive than building it in from the start. Not just in money — in time, risk, and organisational friction.

    When you add a control plane after agents are already in production, you must modify every existing workflow to route through the new layer, backfill logs for actions that already happened, and negotiate with teams accustomed to unfettered agent access. In practice, this work costs roughly three times what it would have cost to build the control plane first — before accounting for the risk exposure during the period agents ran without controls.

    Building it from day one means the control plane is part of the deployment process. Every new agent is onboarded through it. Every execution is logged from the first run. Every cost is tracked from the first token. No migration, no retrofitting, no gap.

    What to Do Next

    If you are running agentic AI in your organisation — or planning to — here is where to start.

    1. Inventory your agents. List every agent, workflow, and automated process that takes action on a business system. Include what systems it accesses, what credentials it uses, and what actions it can perform. You cannot secure what you have not catalogued.

    2. Add structured logging. For every agent execution, log the input, the decision chain, the action taken, the output, and the timestamp. Use a consistent schema. Send these logs to a central, append-only store. If you are using n8n, configure each node to log its input and output. Integrate a tracing tool like Langfuse from the start.

    3. Implement approval gates for high-risk actions. Define which actions require human sign-off: anything client-facing, anything that modifies financial data, anything that changes system configuration. Build the approval gate into the control plane, not into the agent’s prompt.

    4. Set up observability. Deploy an observability layer that tracks execution traces, error rates, token usage, and cost per workflow. Build dashboards. Set alerts for anomalies — sudden cost increases, rising error rates, unusual execution patterns.

    5. Define failure recovery. For every workflow, document what happens on failure. Retry logic, escalation paths, rollback procedures. Test these before you need them.

    The organisations that will extract the most value from agentic AI are not the ones that move fastest. They are the ones that move safely — with the infrastructure to observe, control, and recover from the inevitable failures.

    If you are building agentic systems and need help designing the control plane, observability, and security architecture around them, the AI & Automation Architecture service covers exactly this. For examples of what this looks like in practice, see recent projects.

  • Why Dependency Hygiene Becomes a Leadership Issue

    Why Dependency Hygiene Becomes a Leadership Issue

    A lot of teams still treat package upgrades and release housekeeping as purely technical chores.

    That made sense when the application estate was simpler, the change rate was slower, and a missed patch mostly meant a slightly awkward sprint later on. It makes much less sense once your organisation depends on AI services, automation workflows, customer-facing portals, and a growing set of third-party components that can change under your feet.

    This week’s GitHub activity was a useful reminder of that.

    Across several public repos, the work was not centred on a dramatic new feature. It was centred on the quieter jobs that keep live systems usable: upgrading a framework across multiple sites, tightening the way an agent platform distinguishes billing exhaustion from authentication failure, restoring an explicit safety guard with regression coverage, and shipping deployment handover notes alongside a website redesign.

    That mix matters because it points to a broader operating reality: dependency hygiene is no longer just a developer preference. It has become part of leadership discipline.

    The recent GitHub signals were small, but not trivial

    A few examples stood out.

    One public media/website repo recently went through a cluster of framework upgrades across multiple surfaces. On the face of it, those are dependency bumps. In practice, they are evidence of someone choosing not to let the front-end estate drift quietly into a harder future upgrade.

    Another public analytics/cost-tracking repo saw updates to numerical and coverage tooling. Again, this is the sort of work many leadership teams never see. Yet if cost reporting or analytics underpin operational decisions, stale numerical libraries and test tooling are not invisible engineering details. They affect how confidently the team can rely on output.

    In one public agent platform, a recent change separated billing exhaustion from a generic authentication failure, while another restored a missing enabled-guard and added regression tests. Those are strong examples of operational maturity. The first makes failure states easier to understand. The second makes it harder for a disabled service path to behave ambiguously.

    Then there was website delivery work in a public site repo: one change added a deployment handover document, and another shipped the full site build and deploy tooling. That is not just design delivery. It is an acknowledgement that shipping is only half the job if nobody else can support the result safely afterwards.

    Why senior leaders should care about this work

    If you are a founder, managing partner, COO, CIO, or board sponsor, none of this should be dismissed as back-room maintenance.

    Once AI, automation, or client-facing digital journeys are part of the operating model, dependency hygiene becomes a business issue for three reasons.

    1. Drift increases the cost of every later decision

    Technical drift rarely fails all at once. It accumulates quietly.

    A framework stays two major versions behind. A library update gets deferred because it is inconvenient. A brittle edge case stays undocumented because the team who understands it is still around. Nothing looks urgent until a new feature, security fix, or partner integration suddenly depends on clearing months of deferred maintenance.

    That is when the bill arrives.

    For SMEs and founder-led businesses, that usually shows up as delivery drag. For law firms and healthcare organisations, it can also create assurance problems because the stack behind a client-facing process becomes harder to explain. For PE-backed companies, it turns into diligence friction. If the technology estate looks under-maintained, every transformation claim starts to feel less believable.

    2. Poorly classified failures waste leadership attention

    One of the most useful repo changes this week was not a new feature at all. It was the decision in one public agent platform to separate billing exhaustion from a generic auth failure.

    That matters because leaders make bad decisions when the system reports the wrong category of problem.

    If a model provider has hit a spend limit, that is a budget, quota, or supplier-management conversation. If the credentials are wrong, that is a configuration or secrets-management conversation. If both are lumped together as “auth failed”, the team loses time, the escalation path gets muddled, and confidence in the monitoring starts to erode.

    At scale, this is one of the easiest ways for senior people to get dragged into operational noise that should have been designed out earlier.

    3. Handover quality is part of risk control

    I think many organisations still underestimate how much risk sits in the gap between “it works” and “someone else can run it”.

    That is why the deployment handover work in dh-electrical-uk-website is commercially important. When a redesign lands with deploy tooling and supporting handover notes, the delivery is stronger than a visually successful launch on its own. It means the service is more likely to survive staff changes, supplier changes, holiday cover, and the inevitable moment when something needs to be updated under time pressure.

    In practical terms, handover is where a lot of hidden fragility gets exposed:

    • which versions are actually supported
    • which environment assumptions are undocumented
    • which steps still live in one person’s head
    • which recovery actions have never been written down

    If that sounds familiar, the issue is not documentation style. It is operating-model debt.

    What good leadership looks like here

    The answer is not for non-technical leaders to micromanage every package bump.

    The answer is to treat upgrade hygiene, failure clarity, and supportability as visible management concerns. In practice, I would want four things.

    Keep an explicit tolerance for drift

    Not every dependency needs to be latest immediately. But the organisation should know what level of lag is acceptable, where major-version changes are being deferred deliberately, and who owns the call when a deferral becomes risky.

    Insist on failure signals that guide action

    If an automation platform cannot distinguish billing, auth, config, runtime, and policy problems cleanly, the team will spend too much time diagnosing symptoms and not enough time fixing causes.

    Ask for handover evidence before calling a project done

    If a supplier, internal team, or blended delivery setup cannot show you the deploy path, the support notes, and the recovery assumptions, you do not yet have a finished operational asset.

    Connect maintenance discipline to commercial credibility

    Clients, investors, regulators, and acquirers do not usually ask whether numpy or Astro was bumped on Tuesday. They do care whether your digital services are dependable, whether your reporting is trustworthy enough to guide decisions, and whether your systems can be maintained without heroics.

    That is the commercial expression of dependency hygiene.

    A simple question worth asking this quarter

    If your organisation relies on AI, automation, or a modern web estate, ask one blunt question:

    Which live services would become awkward or risky to change if the current operator disappeared for two weeks?

    The answer usually reveals more than a tooling audit alone.

    It shows where drift has been tolerated too long, where failure messages are too vague to manage well, and where handover has been assumed rather than designed. Those are exactly the places where fractional leadership earns its keep, because the problem is rarely just a code problem. It sits across governance, service design, supplier control, and risk appetite.

    If that question exposes uncomfortable gaps, that is useful. It gives you a practical starting point.

    If you want help turning that picture into a calmer operating model, my services cover the overlap between security leadership, IT direction, and AI architecture. Or get in touch if you want a senior review of where maintenance debt, weak handover, or ambiguous failure handling is making change harder than it should be.

  • Before You Launch an AI Assessment, Fix the Operating Model

    Before You Launch an AI Assessment, Fix the Operating Model

    A lot of AI advisory offers now start with an assessment.

    The problem is that many of these offers are still being built like marketing assets rather than client-facing systems.

    If the output influences buying decisions, budget allocation, compliance posture, or board discussion, the operating model behind it matters as much as the prompt or the front end. Recent GitHub work around an AI consultancy assessment build, plus reliability work in adjacent automation repos, makes that obvious.

    The recent signals are not about polish alone

    One assessment build in particular stood out this week.

    The visible activity was not just about shipping a shiny MVP. It included concrete follow-up work such as:

    • provider fallback handling for report generation
    • safer rendering of generated reports and clearer visitor handoff paths
    • lead email notification flows
    • privacy, GDPR, and security controls
    • a protected admin dashboard for internal review

    That list is commercially useful because it shows the build moving away from “can we generate an AI report?” and toward the harder question: “can we run this as a client-facing service?”

    The same instinct showed up elsewhere. In one public agent platform, recent changes added approval requirements around sensitive gateway replacement paths and tightened behaviour when an API server is explicitly disabled. In another internal management context, recent work also focused on surfacing failed or missing configuration steps as real errors rather than false-green output.

    An AI assessment is a service, not a content asset

    This is the point many firms miss.

    An AI assessment may arrive through a landing page, but from the user’s point of view it behaves like a service. It collects inputs. It processes them. It generates output that may shape strategy. It creates follow-up work for your team. It may retain commercially sensitive information. It may trigger email workflows or lead handling.

    That means buyers, especially in law firms, healthcare organisations, PE-backed businesses, and regulated SMEs, will judge it on more than whether the wording feels intelligent.

    They will care about questions such as:

    • What happens if the model fails halfway through a report?
    • Where does the submitted information go?
    • Who can see the results internally?
    • Will someone follow up while the lead is still warm?

    Those are operating-model questions. If they are answered late, the launch becomes fragile. If they are answered early, the assessment becomes a serious commercial asset.

    The four controls I would design before launch

    When I look at the recent issue set, I see four controls that should exist before any AI assessment is treated as production-grade.

    1. Fallbacks for report generation

    Provider fallback handling is one of the first giveaways that the team is thinking properly.

    If your report workflow depends on a single provider, a temporary outage or degraded model response can turn a promising user journey into a dead end. A fallback model path does not need to be elaborate on day one, but it does need to exist. You should know:

    • which provider is primary
    • which fallback path is acceptable
    • how quality is checked before the output is shown
    • what the user sees if both paths fail

    2. Safe rendering and an explicit handoff path

    Safe rendering and an explicit handoff path may sound like front-end housekeeping, but they are more important than that.

    AI-generated output often carries awkward structure, inconsistent formatting, and the occasional sentence that reads far more confidently than the evidence supports. Treat output rendering as a control surface: sanitize it, structure it, keep the language disciplined, then give the reader a clear next step.

    A practical CTA is part of the safety model here, not just the conversion model. If the output is intended to open a commercial conversation rather than substitute for expert judgement, the interface should say so and point naturally to the services page or the contact page.

    3. Privacy, GDPR, and role-based access

    For UK buyers, especially in legal and healthcare environments, privacy, GDPR, and role-based access are where a build starts becoming credible.

    An assessment tool often collects exactly the sort of operational detail that organisations do not want sprayed across logs, inboxes, and loosely protected admin views. Decide early:

    • what data is stored
    • what is redacted or minimised
    • how long submissions are retained
    • which internal roles can access raw answers
    • what the lawful basis and privacy notice look like

    A protected admin dashboard belongs in the same conversation. Internal convenience is not a good enough reason for weak access control.

    4. Truthful monitoring and approvals around the edges

    The adjacent repo activity matters here because it reinforces a broader discipline.

    If a nightly check can go false-green, or a gateway action can happen without the right approval, your delivery stack is already telling you something about risk appetite. Public agent-platform fixes and internal management work both point to the same lesson: the system around the assessment needs honest signals and controlled change paths.

    For a buyer-facing AI assessment, keep one rule in mind: do not automate yourself into ambiguity.

    If emails fail, surface it. If a fallback is used, log it. If an admin action changes routing or content, require the right level of review. If an integration is disabled, behave safely and obviously rather than trying to muddle through.

    That is how you keep confidence high without pretending the system is infallible.

    Where this lands commercially

    This is not only a product design issue. It affects how the market reads your firm.

    A well-run assessment signals seniority. It tells a prospect that you understand not just AI tooling, but governance, service design, delivery risk, and follow-through. A weakly controlled assessment suggests the front-end story is outrunning the operating reality behind it.

    For founder-led firms, that usually shows up as missed leads, messy handovers, and inconsistent output. For more regulated sectors, it can create trust friction before a proposal is even on the table.

    A sensible pre-launch checklist

    Before putting an AI assessment in front of serious buyers, I would want five things in place:

    • a tested fallback path for report generation
    • sanitised, structured output with a clear advisory disclaimer where needed
    • a defined CTA path into the services page or the contact page
    • privacy, retention, and access decisions written down
    • alerts and admin workflows that fail visibly rather than silently

    That will not make the launch flashy. It will make it usable.

    And in this category, usable beats flashy every time.

    If you are building an AI assessment, advisory funnel, or client-facing automation journey and want the surrounding controls designed properly, my services cover that mix of security leadership, IT operating model, and AI architecture. If you already have something live, get in touch and I can help you pressure-test it before it becomes a trust problem.

  • GitHub Weekly — Inventory Reconciliation, Safer Automation, and Pilot Delivery

    GitHub Weekly — Inventory Reconciliation, Safer Automation, and Pilot Delivery

    When I reviewed this week’s GitHub activity, one pattern kept showing up across very different repos: the work was not really about adding more moving parts. It was about making the existing parts easier to trust.

    That showed up in infrastructure work, in the agent and governance layer, in product scaffolding, and even in website and brand updates. The common thread was operational credibility. Not “can this be built?” but “can this be run, understood, and improved without guesswork?”

    I think that distinction matters more than most teams admit. Plenty of systems can be made to work for a day. Far fewer are built to survive handovers, edge cases, and the quiet failure modes that only show up once the initial excitement wears off.

    What happened

    1. Inventory and infrastructure work moved from assumptions to reconciliation

    The clearest technical thread this week sat in the infrastructure estate.

    A cluster of commits and pull requests focused on inventory reconciliation, NetBox alignment, deployment timers, backup coverage, and preserving state correctly during synchronisation. The details matter here because they point to a mature kind of problem.

    This was not “set up monitoring” or “add a backup.” It was more specific than that:

    • preserving existing custom fields during sync instead of bluntly overwriting them
    • wiring host variables so the live inventory reflects the real estate more faithfully
    • adding a reconciliation timer so drift is checked regularly rather than relying on memory
    • tightening the documentation around port management and incident handling
    • adding backup paths around Git hosting and PostgreSQL exports so recovery is not left to best intentions

    That is serious operational work.

    A lot of teams stop once the first integration works. But once you have lived with an estate for a while, the harder problem is not connectivity — it is fidelity. Does your inventory still describe reality? Does your synchronisation preserve the parts of the system that humans added for a reason? Do your backups exist as a runnable path, not just a sentence in a plan?

    I also noticed a Terraform validation gate land in the same broader operating context. Again, that is a small change on paper, but it says something useful about the direction of travel: the systems are being nudged toward earlier feedback and fewer silent mistakes.

    That is usually a good sign. Mature platforms do not just automate more; they fail sooner and more visibly.

    2. Safer automation is becoming a design principle rather than a patch

    A second pattern was the continued tightening of automation boundaries.

    In the management and agent repos, the work touched cron behaviour, gateway restart safety, regression coverage, secret-scanning governance, prompt and model hygiene, and more explicit handling of runtime assumptions. There was also activity around daily “Decision Desk” issues and weekly cost rollups, which reinforces the sense that operational review is becoming a routine surface rather than an occasional scramble.

    What stood out to me was not any one fix in isolation. It was the posture behind them.

    The posture seems to be:

    • make hidden dependencies visible
    • stop false-green checks from looking healthy when they are not
    • separate human-only actions from safe automation paths
    • keep governance records close to the implementation work
    • add tests around the boundaries that matter most

    That is the right instinct for any agentic or semi-autonomous system.

    There is a temptation in AI and automation work to obsess over capability and underinvest in control. But the systems that earn trust over time are usually the opposite. They may look less flashy at first, but they are the ones people keep using because the failure modes are legible.

    I often find that the best progress in these environments comes from boring-sounding work: a better guard, a clearer runbook, a fix that prevents a check from hiding a broken path, or a cleaner boundary between what the machine can do alone and what still needs a person.

    That kind of work compounds.

    3. New product and pilot work is being framed with real operational shape from the start

    There was also a healthy amount of activity around new product and pilot work.

    One stream built out an AI consultancy-oriented assessment flow with issue scaffolding for the API, persistence, report generation, visitor-safe rendering, lead notifications, privacy controls, and admin protection. Another stream pushed a pilot roadmap forward with legal review notes, request packs, costing artefacts, rehearsal runbooks, and status-gate updates.

    This is the sort of work I like to see early.

    It suggests the projects are not being treated as presentation-layer exercises. They are being built with the surrounding machinery in mind:

    • how the workflow stores and protects data
    • how output gets generated with fallbacks
    • what supporting documents are needed before a pilot becomes real
    • what commercial and legal edges need handling before delivery starts
    • what a rehearsal path looks like before someone is relying on it

    That is a much stronger way to start an AI project than simply chasing a polished demo.

    The same practical mindset also showed up in the website work. The brand alignment and navigation adjustments in the main site repo, along with the redesign and deployment handover work in a separate website project, both point to an important truth: delivery is never just code. It is also handover, consistency, content structure, and operational clarity once the thing is live.

    Why this week matters

    What connects all of this is a shift from implementation to operability.

    I do not mean that the build phase is over. Clearly it is not. There is still plenty being created. But the work is increasingly shaped by questions like:

    • Can this system survive drift?
    • Can somebody else understand the current state quickly?
    • Can an automated path be trusted not to hide the real failure?
    • Can a pilot be delivered without inventing the commercial and governance pieces at the last minute?
    • Can the visible front end stay aligned with the operational reality behind it?

    Those questions are where systems start becoming durable.

    They are also where a lot of technical teams quietly win or lose time. If you skip them, you pay later through rework, brittle deployments, unclear ownership, and incident response that starts with archaeology. If you handle them early, the platform becomes easier to change because it is easier to reason about.

    Key takeaways

    A few practical lessons came through clearly this week.

    • Reconciliation beats assumption. A live inventory is only useful if it keeps matching reality. Sync jobs and timers are not admin overhead; they are how trust is maintained.
    • State preservation matters as much as state collection. It is not enough to ingest live data if the process wipes the context humans added deliberately.
    • Guard rails are product work. In agent and automation systems, restart safety, explicit boundaries, and truthful checks are not secondary concerns.
    • Pilots need legal and operational scaffolding early. Rehearsal runbooks, request packs, privacy controls, and delivery notes are signs of seriousness, not bureaucracy.
    • Good delivery includes the handover path. Website and product work both improve when documentation, navigation, and deployment steps are treated as first-class.

    If I had to reduce the whole week to one line, it would be this: the strongest systems in the batch were the ones being made easier to trust, not merely easier to demo.

    Closing thought

    This week’s most interesting GitHub activity was not one dramatic launch. It was the repeated decision to replace ambiguity with structure.

    That happened in infrastructure reconciliation, in safer automation boundaries, in early-stage product scaffolding, and in content and website delivery work. Each change on its own might look incremental. Together, they point in a useful direction: systems that are easier to operate, easier to hand over, and harder to misunderstand.

    That is the sort of progress I pay attention to.

    If you are building AI workflows, internal tooling, or customer-facing systems and want them to be robust as well as impressive, that is exactly the kind of work I help with through services and more focused advisory conversations via contact.

  • When the Rules Become the Product

    When the Rules Become the Product

    This week kept returning to the same idea: the most useful engineering work is often the work that makes a system easier to trust.

    That does not always look exciting from the outside. It is not always a new feature, a flashy demo, or a dramatic redesign. More often it is the quieter work of making rules explicit, tightening feedback loops, removing ambiguity, and making the next decision easier than the last one.

    Across the repos I watched this week, that pattern showed up again and again. The common thread was less about adding novelty and more about turning guesswork into something people can actually operate.

    What happened

    1. hermes-mgmt kept pushing on cost, routing, and safety

    hermes-mgmt was the busiest repo in the set, and the signal was very clear: the platform is maturing by making its own guard rails stronger.

    A few of the issues were a good reminder that reliability starts with honesty. One thread called out how expensive large context windows become when autonomous loops keep calling them. Another flagged a provider routing problem where fallback behaviour was not matching the intent of the system. There was also a security issue around dependency CVEs and overly permissive local state handling, plus a series of local service defects that needed attention before they could become bigger problems.

    The pull requests told the same story from the implementation side. There were updates around shared spend visibility, stronger routing defaults, helper scripts for operator actions, secret-finding classifiers, carry guard hooks, resilient re-apply logic, memory activation, and better health checks. In plain English: this is the part of the work where a system stops relying on optimism and starts relying on policy.

    That matters because most production problems are not caused by one spectacular failure. They come from small inconsistencies that accumulate until the platform becomes harder to predict than it should be. The work in hermes-mgmt was a good example of the opposite: make the rules visible, make the fallback paths deliberate, and make the expensive behaviour harder to trigger by accident.

    2. ricambio-ai-roadmap moved product behaviour into the open

    The second big theme lived in ricambio-ai-roadmap, where the work on pilot2_email and the surrounding platform showed a lot more operational maturity than a casual observer might expect.

    There were fixes for transient IMAP failures, a fallback provider chain, and intent-based routing. There was also a 48-hour expiry policy, an in-app help section, and review-session documentation that makes the decision path much easier to follow later. At the same time, the live-platform review surfaced issues around basic-auth defaults, placeholder leakage risk, console labelling, and filter gaps.

    That mix is important. It means the project is no longer just building features; it is building a way to reason about those features.

    If a workflow is going to make decisions on behalf of a user, then the decision rules need to be legible. If a review finds a weak spot, the fix should not just patch the symptom. It should make the system easier to explain the next time somebody has to operate it.

    That is why the recent work here feels significant. It is not only improving the product. It is making the product harder to misunderstand.

    3. richardham-web-and-brand treated content and navigation as part of the system

    The web and brand repo had a very different surface area, but the same underlying pattern.

    There was work on missing sector pages, menu ordering, the AI stack page, homepage hero messaging, and proof-point content. There was also a rewrite of a blog post that had been flagged for confidential or internal detail. That kind of content cleanup is easy to underestimate, but it is exactly the sort of work that keeps a site coherent and credible.

    The best websites do not just look polished. They make it obvious where to go next.

    When navigation is clear, a visitor does not have to guess. When page structure is consistent, a service line is easier to understand. When internal detail is removed from public-facing copy, the story becomes more focused and more trustworthy. That is why I think of this sort of content work as part of the system, not a separate marketing task.

    It is also a useful reminder that design discipline and operational discipline are cousins. Both are about reducing friction. Both are about making the important thing easier to find. And both become more valuable as the system grows.

    4. Smaller repos kept reinforcing the same direction

    A few other repos pointed in the same direction even if they were not as noisy.

    dh-electrical-uk-website had redesign work and deploy tooling, which is a nice example of making a site feel more coherent and easier to ship.

    HamMediaLabs, lk-ai-roadmap, control-tower, and ai-cost-tracker all contributed to the broader picture as well: the more a platform matures, the more the useful work shifts toward clarity, repeatability, and control.

    That is a pattern I like because it is easy to miss in the moment. From far away, all of this can look like a list of unrelated tasks. Up close, it is really one story told in different repos: make the rules explicit, make the system observable, and make the next step easier to take.

    Key takeaways

    A few lessons stood out this week:

    • Routing should be policy, not folklore. If a system needs to choose between paths, the choice should be deliberate and explainable.
    • Security work belongs in the main workflow. Review findings, dependency checks, and permission problems are not side quests; they are part of keeping the platform honest.
    • Visibility is worth more than cleverness. Spend tracking, health checks, and honest dashboards make a system easier to run than vague confidence ever will.
    • Content operations matter. Navigation, structure, and public copy are part of the user experience and deserve the same discipline as the code behind them.
    • The best guard rail is a clear rule. The less people have to remember, the less likely the system is to depend on luck.

    Closing thought

    The strongest theme this week was not speed. It was trust.

    A system becomes easier to trust when the important choices are written down, the fallback paths are deliberate, and the rough edges are visible before they become incidents. That is true for routing policies, for security reviews, for website navigation, and for the way content moves from draft to publish.

    If you are trying to make an AI or automation workflow feel less like improvisation and more like operations, the next step usually is not more complexity. It is more clarity.

    And if that is the kind of cleanup you are wrestling with, get in touch.

  • When Systems Stop Relying on Guesswork

    When Systems Stop Relying on Guesswork

    A system usually becomes more trustworthy for one simple reason: the people running it stop having to guess.

    That sounds obvious, but it is often the difference between something that demos well and something that survives real use. Early on, teams tend to depend on memory, informal habits, and whoever happens to know how the pieces fit together. The more a platform grows, the more fragile that becomes. Hidden choices turn into operational risk. Unwritten expectations become inconsistent behaviour. Small misunderstandings start to show up as outages, wasted time, or avoidable rework.

    The most useful progress is often not glamorous. It looks like defining defaults, documenting recovery paths, tightening feedback loops, and making the important steps repeatable. In other words: less mystery, more system.

    What changed

    Across a typical week of work, the strongest improvements usually fall into a few categories.

    1. Decisions become explicit

    A lot of problems come from the same place: a critical choice was never written down.

    That might be a model selection rule, a deployment expectation, a fallback path, or a review step. If the team needs the same answer more than once, it should probably live in a policy, not in somebody’s head.

    Explicit decisions are easier to audit, easier to improve, and easier to hand over. They also reduce the chance that the system behaves differently depending on who touched it last.

    2. Observability becomes truthful

    Dashboards are useful only when they reflect reality.

    It is very easy to build something that looks informative while quietly hiding the thing you actually need to know. Wrong time windows, weak queries, misleading defaults, and over-optimistic thresholds can all create the illusion of control. The result is a lot of visual noise and very little operational value.

    Good observability is boring in the best possible way. It tells you what happened, when it happened, and whether the current state matches the story the interface is telling.

    3. Reuse reduces friction

    Reusable process is one of the highest-leverage things a team can build.

    Runbooks, checklists, CI steps, templates, decision logs, and bootstrap scripts all do the same job: they reduce the amount of context that has to be remembered manually. That makes the next delivery faster, but more importantly it makes the next delivery less dependent on luck.

    A mature team does not just ship features. It also ships the scaffolding that makes future work safer.

    4. Governance becomes routine

    Governance only helps when it is part of the rhythm of work.

    If decisions are captured sporadically, the rationale gets lost. If they are recorded regularly, they start to form a usable memory for the organisation. That is especially important in AI and automation work, where the consequences of a shortcut can show up much later than the moment it was taken.

    Routine does not have to mean bureaucracy. It can simply mean that important questions are answered in the same place, the same way, every time.

    Why this matters for AI and automation

    AI systems are often judged by how clever they look in isolation. That is the wrong benchmark.

    The real test is whether the system can be operated reliably by other people. Can it recover when something fails? Can it explain what it is doing? Can the team change it without fear? Can the output be trusted enough to act on?

    Those questions are answered by architecture, process, and discipline more than by novelty.

    If a workflow depends on a model, the model choice should be deliberate. If a chart drives decisions, it should be accurate. If a process gets used repeatedly, it should be documented. If a system matters, its operation should not depend on tribal knowledge.

    A practical standard

    A useful rule of thumb is this:

    • if it matters, write it down
    • if it repeats, make it reusable
    • if it can fail, define the fallback
    • if it is monitored, make sure the monitoring is honest
    • if it is operationally important, keep the reasoning close to the work

    That standard is not flashy, but it works.

    It makes AI systems easier to run.
    It makes automation easier to trust.
    It makes teams less dependent on memory.
    And it turns a collection of clever individual actions into something more durable.

    Closing thought

    The best systems are not the ones that never need attention. They are the ones that make attention easier to apply.

    When the defaults are clear, the checks are real, and the process is reusable, the whole stack becomes calmer. That is the kind of progress that matters most: not dramatic, but lasting.

    If you are trying to make an AI or automation workflow more reliable, the first step is usually not adding more complexity. It is removing guesswork.

    If you want help turning a messy operational process into something clearer and easier to trust, the AI & Automation Architecture service is a good place to start. Or get in touch for a practical conversation.

  • GitHub Weekly — Trustworthy Systems Through Routing, Observability, and Reuse

    GitHub Weekly — Trustworthy Systems Through Routing, Observability, and Reuse

    Introduction

    Some weeks are about shipping something obvious. Other weeks are about making the systems around the work easier to trust.

    This week looked like the second kind of week. Across the repos I reviewed, the change was direction, not just volume. Model routing became more deliberate. Monitoring became more accurate. Reusable delivery patterns became more explicit. Creative systems got clearer guardrails. And the small operational details that usually sit in the background were pulled into the foreground where they belong.

    That matters because the hardest part of running AI-assisted or automation-heavy systems is rarely the first prototype. The hard part is the handoff from “this works on my machine” to “this can be operated, explained, and improved without guesswork.” This week’s activity was a good reminder that trustworthy systems are built from a lot of very ordinary decisions made consistently.

    What happened

    Model routing stopped being an assumption and became a policy

    The clearest example came from hermes-mgmt. There was a real shift in how model choice is being handled: routing policy updates were merged, a stable default was pinned down, and provider-diverse fallback and outage behaviour were documented more explicitly. On top of that, role-based routing for research, coding, and review was defined instead of leaving model selection to whatever happened to be convenient in the moment.

    A lot of teams start with a simple belief: pick the biggest or newest model and let it do everything. That works until it doesn’t. Once you begin relying on models for different kinds of work, the distinction between “best model” and “best model for this job” becomes the difference between a healthy control plane and an expensive guessing game.

    I like this change because it turns model selection into an operating decision. It acknowledges that research work, coding work, and review work are not the same thing. It also gives the system a way to recover when a provider has issues, rather than forcing every incident into a manual exception.

    The surrounding work supports that direction too. A stale current-state snapshot was refreshed, the wider documentation was merged, and an earlier activation runbook for mixture-of-agents work shows that the system is being treated as something that needs operational memory, not just clever prompts.

    Observability was corrected, not merely expanded

    The biggest lesson from hamnet was the same one I have seen many times in production environments: a dashboard is only useful if it is telling the truth.

    This week’s work there focused on dashboard reliability rather than cosmetic additions. Grafana datasource timing was corrected, time series queries were given explicit intervals, default time windows were adjusted, and Pushgateway queries were wrapped so they render consistently. There was also a practical backlog item to track services that still need HTTPS equivalents, which is the kind of operational debt that gets forgotten unless somebody writes it down.

    I think this is a good example of how observability should be approached. It is tempting to treat monitoring as a collection of panels: add some graphs, colour some thresholds, and call it “visibility.” But real observability is more demanding. It means the query window is right, the step size is right, the defaults are right, and the chart is actually showing the thing you think it is showing.

    That is not a minor distinction. If your dashboard is technically live but operationally misleading, it can create more risk than it removes.

    There was also a useful signal in the issues around connecting a second Hermes instance as a remote subagent. That kind of work says the control plane is no longer just about one local setup. It is beginning to think in terms of distributed operation, where trust, connectivity, and monitoring all need to survive outside a single happy path.

    Creative systems became more governable

    HamMediaLabs showed a similar pattern, but from a different angle. The work there focused on creative-quality instrumentation, creative-ops playbooks, a per-brand visual identity layer, and a short-form voice system.

    That sounds very different from routing policies and dashboard fixes, but the underlying principle is the same: if you want something to scale, you need a repeatable operating model.

    In creative work, people often assume the value lives in taste alone. Taste matters, of course, but once you are managing multiple brands or content streams, taste has to be supported by structure. Otherwise every output becomes a one-off argument.

    The interesting thing here is that the repo is not just producing creative assets. It is creating a system for how those assets should be judged and delivered. That is the right order. First you define the identity. Then you define the checks. Then you can move quickly without drifting away from what the work is supposed to feel like.

    Delivery got more reusable, not just more active

    richardham-co-uk-ConsultancyOS was another good example of this week’s theme. CI was added, licensing and contributing guidance were written, a docs handbook appeared, and a SessionStart hook was introduced. In parallel, there was work on reusable delivery-repo patterns, operational dashboards, and prompt-pack integration.

    That is the sort of repo work that pays off over time in a way that is easy to underestimate.

    Most teams can write a one-off project. Fewer teams can turn that project into a template that makes the next one easier. The difference is not just technical polish. It is whether the project has been made reusable. When the CI, contribution rules, documentation, and bootstrap hooks are all captured explicitly, the next engagement starts with less friction and fewer assumptions.

    I see the same thing in the planning and monitoring work happening in lk-ai-roadmap. The hosting and runtime map was clarified, with a clear “no standing servers” direction. Token usage and cost-versus-budget monitoring were documented. Network and security monitoring agent work moved forward as a pilot spec. And the baseline capture kit and endorsement tracking suggest the project is being built with traceability in mind rather than as an ad hoc collection of tasks.

    That is what mature delivery looks like: fewer hidden decisions, more explicit rules, and less dependence on individual memory.

    Key takeaways

    The pattern across all of this work was remarkably consistent.

    • Policies are better than assumptions. Model routing, fallback behaviour, and role-based usage are clearer when they are written down.
    • Monitoring is only useful when it is accurate. A dashboard with the wrong time window or query behaviour is not a shortcut to clarity.
    • Reuse is a force multiplier. CI, docs, hooks, and templates make the next delivery easier than the last one.
    • Creative work benefits from the same discipline as infrastructure. Identity and quality checks are what make scale possible without drift.
    • Governance works best when it becomes ordinary. The more decisions are captured in the system itself, the less they depend on memory or heroics.

    What I take from this week is simple: the work is moving from experimentation to governable systems. That is a good sign. It means the platform is getting more predictable without losing momentum, and the people operating it are making fewer decisions in the dark.

    That is the kind of progress that compounds.

    If you are building AI systems, automation, or operational dashboards and want help turning the moving parts into something easier to trust, the AI & Automation Architecture service covers exactly this. Or get in touch if you want a practical conversation about making the system easier to run.

  • Why Agentic AI Needs Audit Trails, Not Just Clever Prompts

    Why Agentic AI Needs Audit Trails, Not Just Clever Prompts

    The conversation around AI in business has shifted. For the past two years, most organisations have experimented with generative AI as a productivity tool — drafting documents, summarising meetings, answering questions. The model receives input, produces output, and a human reviews the result.

    That is no longer the whole picture.

    Across the organisations I work with, AI is moving from answering questions to taking actions. Agents execute n8n workflows that move data between systems. They trigger Hermes agents that read, write, and decide. They call APIs, update records, send messages, and make operational decisions — sometimes with human approval, sometimes without.

    This is agentic AI: systems that do not just respond, but act. It creates a governance problem that clever prompts alone cannot solve.

    The Governance Gap

    When a human makes a decision in a business process, there is usually a trace. An email sent, a form submitted, a system log entry, a manager’s sign-off. When something goes wrong, you can reconstruct the sequence of events. You can ask: what were they asked to do, what did they do, and why?

    When an AI agent executes an action, that trace often does not exist. The agent receives a prompt, processes it through one or more model calls, and performs an action. If the action is wrong — if it updates the wrong record, sends a message to the wrong person, or executes a workflow it should not have — the organisation is left with a result and no explanation.

    This is not a theoretical risk. In my own infrastructure, I have built agentic workflows that interact with live systems. The difference between a safe deployment and an unsafe one is not the quality of the prompt. It is whether the system logs enough information to reconstruct what happened after the fact.

    What Happens Without Audit Trails

    Without audit trails, three things break down.

    You cannot reconstruct events. If an agent produces an incorrect output or takes an unintended action, you need to know what input it received, which model or tool it called, what intermediate decisions it made, and what action it executed. Without this, debugging is guesswork. You are trying to diagnose a problem without access to the patient’s notes.

    You cannot establish accountability. When an automated system causes harm — a data breach, a financial error, a compliance failure — someone needs to be able to explain what happened. Under UK GDPR, the accountability principle requires organisations to demonstrate compliance, not just claim it. If your AI agent processes personal data and you cannot show what it did with that data, you are not compliant. It does not matter how good the system is in theory.

    You cannot improve the system. Agentic AI systems iterate. You adjust prompts, change tool configurations, add guardrails. Without structured logs of what each execution actually did, you are optimising in the dark.

    What a Practical Audit Trail Looks Like

    An audit trail for an agentic AI system does not need to be complex. It needs to be consistent and complete. At minimum, each agent execution should capture:

    • Input received. What was the agent asked to do? This includes the user’s request, any system context, and the prompt that was constructed.
    • Decision chain. What steps did the agent take? Which tools did it call? What intermediate outputs did it produce? For multi-step agents, this is the sequence of reasoning that led to the final action.
    • Action taken. What did the agent actually do? Which API was called, which record was updated, which message was sent.
    • Output produced. What was the final result returned to the user or passed to the next step in the workflow.
    • Timestamp and identity. When did this happen, and which agent or workflow executed it?

    This is not excessive. It is the same information you would expect from any business system that takes actions on data. The fact that the system is powered by a language model does not change the requirement — it increases it, because the system’s behaviour is less deterministic and harder to predict.

    The Regulatory Dimension

    For UK organisations, this is not optional. UK GDPR Article 5(2) establishes the accountability principle: you must be able to demonstrate that you comply with data protection principles. If an AI agent processes personal data — and most business agents do — you need to show what data it accessed, what it did with that data, and on what basis.

    Article 30 requires records of processing activities. An agent that processes client records, employee data, or customer information is conducting processing activity. If you cannot produce a log of that activity, you do not have the records the regulation requires.

    For financial services firms, the FCA’s operational resilience framework adds another layer. Important business services must withstand disruption and recover. If your AI agents are part of an important business service — processing transactions, managing client communications, monitoring risk — you need to understand how they behave, what they depend on, and what happens when they fail. Audit trails are the evidence base for your resilience assessment.

    How to Implement Audit Trails in Agent Workflows

    The good news is that the tooling exists. You do not need to build this from scratch.

    Structured logging at every node. In n8n workflows, each node can be configured to log its input and output. For agentic workflows, you should log at minimum the trigger, each decision point, and the final action. Use a consistent schema — timestamp, node name, input summary, output summary, and execution status — so that logs are searchable and comparable.

    Observability platforms. Tools like Langfuse are designed for exactly this purpose. They capture the full execution trace of an agent: prompt, model response, tool calls, and final output. When connected to your workflow engine, they give you a queryable record of every agent execution without building custom logging infrastructure.

    Immutable storage. Audit logs must be tamper-evident. If the log can be modified after the fact, it is not an audit trail — it is a diary. Store logs in append-only storage with access controls that prevent modification. This can be as simple as writing to a write-once bucket or using a logging service that enforces retention policies.

    Structured output from agents. Design your agents to return structured output, not just free text. A JSON response that includes the action taken, the target system, and the rationale is far more useful for auditing than a paragraph of prose. This also makes it easier to validate agent behaviour programmatically — you can check that the action taken is within the set of permitted actions before it executes.

    Regular review. Audit trails are only useful if someone looks at them. Build a review cadence — weekly for high-risk agents, monthly for lower-risk ones — where you sample executions and check for anomalies.

    The Bottom Line

    The organisations that will get the most value from agentic AI are not the ones with the most sophisticated prompts. They are the ones that can trust their agents to act safely, verify what those agents did, and improve them over time.

    Audit trails are the foundation of that trust. They are how you move from hoping your agents behave to knowing they do. They are how you satisfy regulators, reassure boards, and sleep at night.

    If you are deploying agentic AI in your organisation — or planning to — audit infrastructure is not a phase-two consideration. It is a prerequisite.

    If you are building agentic AI systems and need help establishing the governance, architecture, and audit infrastructure to support them, the AI & Automation Architecture service covers exactly this. For a broader conversation about where your organisation stands, get in touch.

  • The Case for Explicit Policies

    The Case for Explicit Policies

    Reliable systems do not emerge from good intentions. They emerge when the rules are explicit enough that another operator can understand what the system is supposed to do without reverse-engineering its behaviour from the wreckage.

    That sounds obvious, but it is still one of the most common gaps I see in automation and AI work. Teams build the workflow, connect the services, and get something working end to end. Then they leave the important decisions half-stated. Which provider is preferred? When should the fallback fire? What counts as a real health check? Which version of a process note is authoritative? The system may run, but the operating model is still fuzzy.

    The problem is not that people are careless. It is that policy work often looks less urgent than delivery work. Until something breaks, the invisible rule feels good enough.

    Where ambiguity shows up first

    The first place ambiguity appears is usually routing.

    A stack with multiple models, providers, queues, or execution paths always contains policy whether the team writes it down or not. If the preferred provider is too expensive for low-value tasks, that is policy. If one model is allowed for drafting but not for final output, that is policy. If a workflow should fall back only on timeout and not on quality failure, that is policy too.

    When none of that is written down clearly, people start inferring intent from whatever happened last.

    That is how teams end up with arguments that sound technical but are really operational:

    • “I thought the cheaper path was the default.”
    • “I assumed the fallback only applied during outages.”
    • “I didn’t realise this job was meant to stay on the private model.”
    • “I thought the dashboard alert meant the workflow had already rerouted.”

    None of those are bugs in isolation. They are symptoms of unstated policy.

    Why observability is part of policy

    The same issue appears in monitoring.

    A lot of dashboards tell you that a process is alive. That is not the same as proving the service is doing the right thing.

    For AI and automation systems, a truthful check usually needs to answer something more useful:

    • did the workflow complete the task it was supposed to complete?
    • did it use the intended path?
    • did it return data that looks structurally valid?
    • did the fallback stay dormant when the primary path was healthy?
    • can the operator see enough detail to explain the outcome afterward?

    If the check cannot answer those questions, the dashboard may still be visually tidy, but it is not giving the operator what they need.

    This is why I think observability should be treated as policy, not just instrumentation. The team has to decide what “working” actually means. Otherwise the monitoring layer simply reflects a vague assumption instead of a deliberate standard.

    Reuse is how policy survives handover

    The other quiet benefit of explicit policy is reuse.

    If a team has to rediscover the same routing rule, the same rollback sequence, or the same publishing checklist every time, then the policy is not really part of the system yet. It still lives in memory.

    That is expensive in a small team and dangerous in a growing one.

    Good reuse does not have to be elaborate. Often it is just a set of plain habits:

    • keep one canonical source of truth for important workflows
    • write fallback conditions near the implementation
    • keep short runbooks for the obvious failure modes
    • use the same naming and review patterns across similar jobs
    • record decisions before context evaporates

    None of that feels exciting while you are doing it. But it changes the quality of handover completely. A new operator no longer has to absorb the entire history of the stack before they can act safely.

    What explicit policy looks like in practice

    In practical terms, I look for a few simple signals.

    1. The preferred path is obvious

    The system should make it clear what happens first, what happens second, and under which conditions the fallback is allowed to take over.

    2. The checks reflect user reality

    A green dashboard should mean more than “something is listening on a port”. It should tell the operator whether the real job still works.

    3. Recovery paths exist before the incident

    If the first time a team documents the rollback sequence is during a failure, the policy work happened too late.

    4. Repeated patterns are actually reusable

    If the same kind of workflow appears three times, there should be a shared pattern instead of three slightly different tribal versions.

    Why this matters more with AI systems

    AI systems raise the cost of ambiguity because they turn a fuzzy rule into machine-speed inconsistency.

    In a manual process, unclear policy wastes time. In an automated one, it can silently change outputs, route work to the wrong provider, or create a trail that is too vague to audit later.

    That is why I think trustworthy AI is less about magic prompts and more about explicit operating rules.

    If the rules matter, write them down.

    If the outcome matters, check the real behaviour.

    If the workflow repeats, make it reusable.

    That does not make the system flashy. It makes it dependable.

    And in production, dependable usually wins.

    If you are building automation that needs to survive handover, escalation, and real operational scrutiny, the AI & Automation Architecture work is designed for exactly that. Or get in touch if you want a second pair of eyes on the operating model before the ambiguity becomes expensive.

  • Why AI Workflows Need Audit Trails

    Why AI Workflows Need Audit Trails

    The conversation around AI has shifted. It is no longer just about drafting text or summarising meetings. More and more often, these systems are taking actions on live business processes.

    That is where the risk changes shape.

    A clever prompt can produce a good-looking result. It cannot tell you what happened after the fact if the output was wrong.

    The gap

    When a person makes a decision in a process, there is usually some trace of it. An email, a ticket, a sign-off, a log entry. With an AI system, that trace is often thin or missing.

    If the system updates the wrong record or sends the wrong message, the team is left with a result and very little explanation.

    What breaks without logs

    • You cannot reconstruct the sequence of events.
    • You cannot show who approved what.
    • You cannot improve the workflow with confidence.

    That is not just a debugging problem. It is an accountability problem.

    What a useful audit trail looks like

    At minimum, every execution should capture:

    • the input it received
    • the steps it took
    • the action it actually executed
    • the output it produced
    • the timestamp and identity of the run

    That is enough to answer the questions that matter later.

    The practical bit

    The tooling is already there. Structured logs, append-only storage, and reviewable traces are all enough to get started. The main thing is to design for visibility before the workflow is under pressure.

    If the system is allowed to act, it should also be required to explain itself.

Powered by