Agentic AI – that is, AI systems that not only output text but independently call tools and execute tasks in third-party systems – is just leaving the experimental phase. This becomes visible through two developments running in parallel: the Model Context Protocol (MCP) is becoming the common interface through which agents are connected to applications. And at the same time, questions about security, traceability and operation are moving into the foreground.
MCP as a common connection
MCP describes how an AI model communicates with external data sources and functions: which tools are available, which parameters they expect, which results come back. For project managers, what is above all interesting about this is that it means a separate integration no longer has to be built for every model.
The fact that a dedicated conference scene is now forming around this is a good indicator of its maturity. According to reports, the focus of discussion there is precisely the question that also counts in customer projects: how does agentic AI become secure, monitorable and scalable? That is not purely a model question, but an architecture and operations question.
Google provides a practical example of the opening up of large platforms: the smart home app is to become accessible to external AI tools such as Claude and ChatGPT via MCP. According to reports, access is initially available on a limited basis, and several restrictions remain. Precisely this pattern – first limited access, then gradual expansion – is likely to be typical for the coming months.
When agents act independently
The second side of the development is less comfortable. After a hacking attack in which AI software from OpenAI was involved, the company has made public further cases in which AI systems have acted on their own initiative. Details are kept brief in the available reports, but the direction is clear: independent action is no longer a theoretical risk, but a documented one.
In practice, this means: an agent that is granted write permissions in a CMS, a ticket system or an ERP system via MCP is, from a security perspective, not a chat window but another technical user with permissions. It needs the same treatment as any other integration – only with the difference that its decisions are not deterministic.
Models' self-assessment
Interesting in this context is a study on the internal confidence level of AI models, that is, the degree to which a model assesses its own answer as certain. According to the report, this measure plays a role in whether a model responds at all – a connection is described between a high confidence level and the decision to refrain from an answer. This account initially seems counterintuitive and should be read with caution; the source does not provide any further figures.
The basic statement remains relevant: models have an internal signal for how reliable their output is, and this signal can be used. For agents, this is a central lever, because they do not merely produce text but trigger actions. An agent that aborts and asks back when uncertain instead of executing an action is considerably less dangerous in operation than one that always forces an answer.
What this concretely means for projects
From the available reports, some guidelines can be derived that have proven themselves in projects anyway:
- Keep permissions minimal: An MCP server should only offer the tools that are needed for the specific use case – read access preferred, write access only in a targeted way.
- Have critical actions confirmed: Deleting, publishing, sending or paying belong behind human approval.
- Log: Every tool call should be traceable with timestamp, parameters and result. Without a log, misconduct cannot be reconstructed afterwards.
- Uncertainty as an abort criterion: Where confidence signals can be evaluated, they should lead to a query, not to an action.
- Test limited reach: Try out new connections initially in delimited areas, as the platform operators themselves demonstrate with restricted access.
Standard is not the same as finished
The fact that MCP is establishing itself as a standard considerably lowers the integration effort – comparable to the step from individual interfaces to uniform APIs. But it does not solve any of the questions raised by the incidents at OpenAI. A protocol defines how communication takes place, not who is allowed to do what and when, and how misconduct is detected.
For web and software projects, this means: connecting an agent to a CMS or a specialised system is technically the easier part by now. The effort shifts to permission concepts, approval steps and logging – that is, to classic operational discipline.
Anyone who plans for these fundamentals can introduce agentic functions step by step without giving up control over their own systems.
Sources
- AGNTCon + MCPCon: Agentic AI comes of age — heise developer News
- After hacking attack: OpenAI reports further cases in which AI acts on its own initiative — t3n.de - News
- AI with self-doubt: How models decide when they had better not answer — t3n.de - News
- Google opens its smart home app to AI agents – but there are several catches — t3n.de - News