Positions on running AI inside an organization: ownership, permissions, cost, vendors and the work nobody budgeted for.
Connecting an internal assistant to SharePoint and file shares surfaces documents people could always technically open but never found, and answers from stale documents with the same confidence as current ones.
Open-weight models bypass the governance and supply chain controls enterprises built for software, leaving internal teams as de facto maintainers.
An agent can write technically correct code that misses the point. Most of the time it isn't the model; it's missing information about your architecture, conventions, business rules and decision history.
Agents can call APIs directly, but production integration work is about retries, idempotency, audit trails, and failure modes—not just making the call.
Prompt engineering didn't disappear. It spread. Better models lowered the need for clever phrasing, not the need for judgment: knowing what to ask for, and what to check.
Prompt injection is not a model vulnerability. It is a data flow problem—the SQL injection of the LLM era—and the fix is the same: separate code from data.
The first production invoice for an AI feature is often the first time a finance team sees a variable cost line item that isn't raw cloud compute.
The gap between a quick AI coding demo and production-ready code isn't the model's capability. It's the instructions. Give the agent your playbook and run it through the same checks as people.
A one-line prompt edit can change what your whole team ships. If an AI instruction can change an outcome, it needs a change process: a source of truth, review, tests, an owner and rollback.
Business users can now build working internal tools in an afternoon. The same pattern as the Access databases and Excel macros that later turned up in migration inventories, but faster: useful, unowned, undocumented, and critical to a process nobody mapped.
AI agents that spend money or change production systems need delegated authority, aggregate limits, segregation of duties, reversibility, and legible audit trails—not just API keys.
Teams debate leaderboard rankings before defining what a good answer looks like. The model matters, but the workflow around it is what lasts and what determines whether you can trust the output.
If your team keeps making the same edits to AI drafts, write those edits down. A house style turned into AI instructions makes drafts faster to review and more consistent from the start.
The moment you hand a task to an AI agent, you find the written procedure only covers the happy path. Mapping the real workflow is the foundation of automation, and often worth more than the automation itself.
How to evaluate AI features that arrive in renewals as new SKUs, price uplifts, changed data-use terms, and opt-out defaults.
AI agents are neither users nor applications, and enterprise IAM processes have no bucket for them. The result is overprivileged tokens, broken audit trails, and no lifecycle management.
A failover in a generative AI pipeline is not an availability mechanism. It is a vendor change, a model change, and often a compliance breach, all happening in milliseconds without the application knowing.
Line-by-line translation preserves the structure, naming, and control flow of the source language. The result compiles, passes tests, and is miserable to maintain.
Generated code replaces dependencies with private maintenance burdens, and model competence tracks public code volume, concentrating enterprises on fewer languages.
Model providers retire versions on cycles measured in months. Enterprise change control assumes software changes when you decide it changes. Pinned versions eventually disappear; floating "latest" aliases change behavior without a release note. How to run AI in production when the dependency moves on its own schedule.
Models change every few months. What survives the change is a test set that encodes your business: the tricky support tickets, the contract clauses that trip people up, the answers that must never be given. Building one from material you already have, and why it is the first thing to fund.
A practitioner's decision rules for choosing between a vendor-hosted MCP server, an internal MCP server, and a direct API client for enterprise agents.
Enterprise AI governance reviews use cases and product names. The actual risk lives in service account permissions, connector scopes, and write actions nobody sees.
A support bot answers from the knowledge base, and deploying one reveals what is in it: outdated procedures, contradictory articles, and fixes that live only in senior technicians' heads. The real project is the content, and keeping it current afterward.
AI saves minutes, but finance budgets in full-time equivalents. The units do not match, and the savings land where the work happens, not where the tool is bought.
Enterprise AI pilots fail when they succeed without a production path. The real costs are integration, operations, evaluation, and ownership, not the model.
Switching model providers looks like a configuration change. In practice, prompts are tuned to one model's habits, vector stores must be re-embedded, fine-tunes don't port, and nobody knows whether the new model handles the edge cases.
A practical breakdown of the three technologies sold as AI watermarking, where each fails in an enterprise publishing pipeline, and how to sort content by blast radius before buying or deploying anything.
The most reliable gains in legacy modernization come from explanation: summarizing what a COBOL program does, extracting business rules, generating characterization tests, drafting the documentation nobody wrote. Automated translation is still the riskier half.
AI-drafted documents, chat histories, and agent action logs raise questions records managers have not had to answer: are prompts discoverable, how long are conversations retained, what goes under legal hold, and who counts as the author of a document drafted by a model and approved by a person?
AI judges have tastes. Some prefer their own output, some prefer longer answers, some prefer a particular vendor's style. Where automated evaluation works, where it quietly biases outcomes, and where a human still has to choose.
A workload-by-workload look at when on-prem inference makes sense, when the API wins, and what flips the answer.