Unsupervised Agent: Where Will It Send a Request at 3 AM

Microsoft Foundry released Routines and egress controls. Learn why autonomous agents need a network boundary beyond code—and how to build one without Azure.

  • Two features worth reading together
  • What exactly was released
  • Why this is one story
  • Why the rules must live outside the agent

Two features worth reading together

Microsoft released two features in Foundry

Routines are now GA: the agent starts automatically on a schedule or event, with no person present at that moment.

Egress traffic control for hosted agents is still in preview.

It answers the question facing any unsupervised agent: where this process is allowed to send a request.

My thesis: the answer to this question must remain outside the agent's code.

Without this, the security team will not approve an autonomous agent for production—and it will be right not to.

What exactly was released

### Routines: running without a human The first generation of agents worked like chat: a person wrote, and the agent responded. Routines launch an agent based on triggers.

The agent handles a new issue in GitHub, responds to a message in a Teams channel, prepares a report every morning, or periodically checks a long-running process until it finishes. Microsoft itself lists what teams previously had to build around an agent by hand: schedulers, event listeners, webhooks, queues, infrastructure, authentication, run history, and monitoring.

The list is accurate: anyone who has brought an agent into regular operation knows that the agent itself accounts for only a small part of such a project. ### Egress controls: the boundary for outbound calls

The second feature defines where a hosted agent can connect over the network.

Rules are stored at the platform level, not in the agent’s code

Microsoft recommends this order: first observe the agent’s real calls, then enable an explicit boundary and verify that required calls pass. Status: preview; there is no SLA, and Microsoft does not recommend using the feature in production.

Why this is one story

In a chatbot, a person provides oversight: they see every response and can stop the conversation. A person cannot see a Routine that starts at three in the morning. Microsoft demonstrates this with an invoice-processing agent.

For the task, it needs two APIs: find a supplier and check a payment record.

Then a document arrives with a link to an unfamiliar upload service.

Or a new helper library makes a request to a URL the developer did not know about.

The list of tools assigned to the agent does not protect against either case: the request bypasses it. In the first case, the request is sent by a model that read someone else’s instruction in a document (prompt injection); in the second, by a transitive dependency.

So the security specialist must ask where this process can physically send data. The question “which tools were given to the agent”

does not answer this

For an agent that handles invoices and payment data, the consequences are measured in money.

Assess where AI can deliver impact in your process

Why the rules must live outside the agent

  1. The agent's code changes every week, some of it is written by the model, and its dependencies include dozens of packages.

  2. If the domain allowlist is in the same code, the same error it is meant to protect against can break it.

  3. A separate person reviews the network rule at the platform or proxy level.

  4. The rule exists in one place, can be audited, and can be changed without releasing the agent. This principle has worked in integrations for twenty years.

  5. We build integrations between 1C, PIM, marketplaces, and warehouses through buses: Datareon, MuleSoft, Talend ESB, Apache Kafka.

  6. Every flow follows a defined route, and the participating system does not decide for itself where to send the data.

  7. An agent is another participating system, but with unpredictable behavior.

  8. That is why it requires more controls than a standard integration.

How to address this now, without GA or Azure

Most of our clients in CIS cannot use Foundry.

The pattern does not depend on Foundry and can be applied to any stack, including GigaChat, YandexGPT, and Qwen in a self-hosted environment.

We build it from five parts. 1. Observation period.

The agent runs in a test environment, and all outgoing calls are logged.

After a couple of weeks, the team has an actual map: which domains are required and which appeared accidentally. 2. An egress proxy with an explicit allowlist.

The proxy blocks calls to domains outside the list and raises an alert.

If a new library makes an external call, the team will find out on the very first day. 3. LLM & Security Gateway for model calls.

The gateway masks personal data, enforces spending limits, and logs requests and responses.

The model receives only the data it is supposed to see

4. Tools exposed through MCP servers with narrowly scoped permissions. The agent receives the operation “check the payment status by account number”

, it does not have full access to the database.

If an attacker extracts the prompt, they get one harmless function. 5. Triggers and schedules through a bus or n8n.

The bus and n8n already provide run history, retries, and monitoring.

You will not need to write a custom scheduler for a single agent.

What does time to result have to do with it?

In our experience, a security boundary adds one or two weeks to an agent launch. Executives often see this as a delay. Without the boundary, security will not let an agent that handles payments move beyond the pilot, and time to value becomes infinite. I have seen this scenario many times: the demo impresses the board, then sits in approvals for six months and quietly dies.

The budget is spent, the metric has not moved, and someone will have to answer for the pilot. The scenario “the agent processes invoices by itself every morning”

looks simple, but requires tedious engineering: call logs, a proxy, a gateway, narrowly scoped tools, and a bus. Engineers do this work, and it is what separates an agent in production from an agent in a presentation.

Conclusion

  1. In one week, Microsoft acknowledged two things.

  2. Agents are moving from chat to background work.

  3. A background agent needs a network boundary that it cannot rewrite itself.

  4. There is no need to wait for the vendor's GA: an agent's network boundary can already be built from established components.

  5. My prediction: companies that build this boundary this year will launch autonomous agents in weeks, while the rest will keep presenting pilots to their boards for a long time.

Discuss the article: Unsupervised Agent: Where Will It Send…

Enter your email or phone number so we can get back to you.

Send via: