I made legacy SOAP APIs usable by AI agents

The Hook

Our machine scans its full source pool every hour. and measures where the industry actually converges — so you get the substance, not the scroll. Today: a single open-source adapter just unlocked decades of enterprise SOAP APIs for AI agents, a deepfake-audio arms race lands a new defensive milestone, and PyTorch quietly gets faster on every MacBook in your office. If you want to use AI at work — not just read about it — you are in the right place.

The Signal

1. The SOAP Adapter That Could Unlock Enterprise AI Automation

An engineer published legacy2mcp, an open-source Model Context Protocol adapter that wraps SOAP-based web services into tools an AI agent can call directly. SOAP — Simple Object Access Protocol — is the XML-heavy standard that still powers the back-end of most large enterprises: healthcare records, banking transactions, insurance workflows, government systems. These APIs were never designed to be called by language models. They speak a verbose, schema-heavy dialect that modern AI tooling ignores. legacy2mcp changes that. You describe your SOAP service's WSDL schema once, and the adapter surfaces it as a clean MCP tool any compatible agent runtime can invoke. The practical implication is significant: automation blocked by the objection 'we cannot expose that system' may now be unblocked by a single middleware layer. This is the kind of quiet, unglamorous infrastructure work that actually moves enterprise AI from proof-of-concept to production.

2. SNAP Closes a Deepfake Audio Evasion Vector

A research team introduced SNAP (Speaker Nulling for Artifact Projection), a technique that strips speaker-identity artifacts from audio deepfake detectors. Here is why that matters: most current detectors do not just look for synthesis artifacts — they inadvertently learn to recognise specific speakers. An attacker who knows this can craft synthetic audio that evades detection by leaning on a voice the detector has seen before. SNAP removes that shortcut, forcing the detector to focus on actual synthesis fingerprints rather than voice-identity cues. The result is a more robust, harder-to-evade detector. For anyone building voice-verification pipelines — authentication systems, fraud detection, compliance recording — this paper is directly actionable. The arms race between synthetic speech and detection is accelerating, and SNAP is a meaningful step for the defensive side.

3. A Scalpel for Transformer Interpretability

A new paper introduces an influence score that quantifies exactly how much each attention head in a transformer classifier contributes to a given decision at inference time. Until now, interpretability work relied heavily on ablation — you disable a head, re-run the model, and see what changes. That is slow, expensive, and imprecise. The influence score is computed analytically, giving you a ranked map of head contributions without re-running anything. For practitioners building classifiers on top of fine-tuned models — intent detection, content moderation, prompt routing — this is a debugging superpower. When your classifier makes a wrong call, you can now trace which heads drove the error and intervene at the right layer. Interpretability is moving from research curiosity to practical engineering tool.

4. Better Privacy, Better Accuracy — A Federated ML Win

A new paper tightens learning guarantees for relaxed local differential privacy, achieving better accuracy on density estimation without loosening the privacy promise. Local differential privacy is the model used in federated learning: each device adds noise to its data before sending it, so the central server never sees raw inputs. The problem has always been that strong privacy comes with a steep accuracy cost. This work introduces a relaxed condition — privatised distributions close in total-variation distance — and proves you can learn better estimators under it. For teams building federated ML pipelines over health, financial, or on-device data, this is a signal that the privacy-accuracy trade-off is shrinking. Tighter math means a stronger story to regulators without crippling your model.

5. Wall Street Just Priced the Nuclear-AI Bet

An analyst issued a 23.7% upside call on NuScale Power, a small modular reactor company, projecting gains over eleven months. The thesis is not complicated: AI data centres need electricity that is always on, carbon-free, and grid-independent — and small modular reactors are the only credible technology delivering all three on a horizon short enough for hyperscaler planning. Large technology companies have been making nuclear offtake moves in recent years. Pure-play public companies remain rare in the space. This is not a momentum trade — it is the market pricing a real infrastructure bottleneck. For anyone tracking AI compute costs, the energy layer is becoming as strategically important as the chip layer.

6. The Nordics Data: A Startup Region Punching Above Its Weight

Recent empirical growth data on the fastest-growing Nordic startups shows numbers that are striking relative to the region's population size. The Nordics continue to produce AI and SaaS exits at a strong pace. The structural reasons are well-documented: high engineering talent density, strong public digital infrastructure, and a culture that treats B2B software as a prestige sector. For founders sizing up where to build or raise in Europe, the Nordics data suggests this is a talent market that is underpriced relative to the deal flow it generates. A useful benchmark for anyone tracking EU AI investment activity.

7. PyTorch Quietly Gets Faster on Apple Silicon

PyTorch merged a small but meaningful change: the CPU fallback gate for SVD (Singular Value Decomposition) on Apple's MPS (Metal Performance Shaders) back-end has been removed for small-matrix inputs. Previously, PyTorch silently fell back to the CPU for small SVD operations even when the GPU was available. That gate is now gone. SVD is used throughout machine learning — PCA, low-rank approximations, LoRA fine-tuning, attention score decomposition. If you run any of these workflows locally on an Apple Silicon Mac, your small-matrix operations now stay on-chip automatically. No code change required — just update PyTorch. A zero-configuration speedup worth taking today.

8. Geospatial Gets an AI Moment

c2cgeoportal, an open-source geospatial platform, released version 2.8.1 of its admin interface. The release itself is incremental, but the signal is worth noting: geospatial platforms are seeing renewed investment and active maintenance cycles because location intelligence is becoming a first-class input to AI pipelines. Mapping data, satellite imagery, routing graphs, and geographic context layers are all being wired into agentic systems for logistics, urban planning, environmental monitoring, and field operations. A steady release cadence on a platform like c2cgeoportal suggests the developer ecosystem around geospatial tooling is growing rather than stagnating. If your work touches location data, now is a good time to evaluate whether your geospatial stack is AI-pipeline-ready.

Quick Hits

• The NuScale analyst call is the clearest sign yet that AI infrastructure investing has moved from the chip layer to the energy layer — the hyperscaler power race is now moving stock prices.
• Update PyTorch today if you are on Apple Silicon: the CPU fallback for small SVD operations is gone and the speedup is fully automatic.
• SNAP is the deepfake-audio paper to read if you are building any voice-verification or fraud-detection pipeline — it closes a known evasion vector attackers were actively using.
• The Nordics startup growth data from Sifted is a useful EU benchmark: 27 million people, exit rates that outpace most comparable European cohorts.

The Cold Open

A vast amount of business logic remains locked inside SOAP services today. — the kind running insurance claims, healthcare records, and logistics systems that enterprises have been promising to modernise for fifteen years. Those systems are not going anywhere. The budgets to replace them are not materialising. But an AI agent that could simply call them — without a full rewrite — would change the calculus entirely. Today, an engineer opened that door. It is a small open-source adapter. It is unglamorous infrastructure. It may be the most practically important thing in this issue.

The Anchor

legacy2mcp: The Bridge Between AI Agents and the Enterprise Past

The Model Context Protocol (MCP) was designed to give AI agents a standardised way to call external tools and data sources. One protocol, many compatible services — a universal connector layer for the AI-native world. What MCP did not solve — by design — is the enormous universe of existing enterprise services that predate it by two decades and speak a completely different language.

That language is SOAP. SOAP (Simple Object Access Protocol) was the dominant enterprise API standard from roughly 2000 to 2015, before REST and JSON APIs became the norm. It uses XML envelopes, WSDL schema files, and a verb-based calling convention that is verbose by modern standards but extremely expressive. It also enforces strong contracts — every operation is schema-defined, every response typed. For the enterprises that depend on it, that strictness is a feature. It is what makes SOAP services auditable, predictable, and stable across decades of production use.

The problem is that modern AI tooling was built for a REST-and-JSON world. When an enterprise team tries to wire an AI agent to a SOAP back-end, they hit a translation wall: the model expects clean JSON tool schemas, and the SOAP service speaks XML with a WSDL descriptor that no current agent SDK natively handles.

legacy2mcp solves this with a single adapter layer. You point it at a WSDL file. It parses the service definition, extracts every available operation and its parameters, and generates MCP tool definitions that an agent can discover and call. At runtime, when the agent calls the tool, the adapter translates the JSON call into a properly formed SOAP envelope, sends it to the service, parses the XML response, and returns clean JSON back to the agent. The SOAP service never knows it is talking to an LLM. The model never knows it is talking to SOAP.

The strategic implication is larger than it looks. A typical large enterprise runs dozens of SOAP services — ERP connectors, HR systems, claims processors, order management pipelines. Each one has been declared out of scope for AI automation because nobody wants to rewrite it. With an adapter like this, the scope objection collapses. The adapter is the bridge, not the rewrite — and the risk profile is completely different. For teams building enterprise agents on the OpenAI stack, this is infrastructure worth evaluating immediately.

Deep Dive

How the Transformer Influence Score Actually Works

Transformer models — the architecture behind GPT, BERT, and every modern LLM — use a mechanism called multi-head attention. At each layer, multiple attention heads run in parallel, each learning to focus on different relationships in the input sequence. In a classifier (a model fine-tuned to assign a label to a prompt), the final prediction is the aggregate result of all these heads working together across all layers. When the model makes a wrong call, you have historically had no fast way to know which heads were responsible.

The standard diagnostic method was ablation: disable one head by zeroing its output, re-run the model on your test input, and observe how much the prediction changes. Repeat for every head across every layer. Across a model's layers and attention heads, diagnosing a single example can require many forward passes. For larger models with 24 or 32 layers and 16 heads, the number becomes operationally prohibitive — you cannot run that diagnosis in a debugging loop.

The new influence score paper takes a fundamentally different approach. It defines the influence of an attention head mathematically — essentially the directional derivative of the model's output with respect to that head's contribution — and computes it analytically using gradient information that is already available during a single forward-backward pass. One pass through the model, and you get a score for every head simultaneously. No rerunning, no 144 experiments.

The score is signed and normalised: a positive value means the head pushed the model toward the correct label; a negative value means it pushed the prediction away from it; the magnitude tells you how strongly. You sort all heads by absolute influence score and immediately see which ones are load-bearing for a given prediction and which ones are effectively bystanders contributing near-zero signal.

The practical applications go beyond debugging. Heads with consistently near-zero influence scores across your entire test set are strong candidates for pruning without meaningful accuracy loss — the influence score becomes a compression signal. And for teams building classifiers on top of fine-tuned models, the technique enables a new kind of explanation: not just 'the model was 87% confident,' but 'here are the three heads that drove this prediction and the two that were working against it.' That is the difference between a classifier you can audit and one you have to trust blindly.

One Technique

Wrap Any API as an OpenAI Function Tool in Under 30 Minutes

If your team uses any third-party or internal API regularly — a data service, a CRM endpoint, a legacy system — you can expose it to the OpenAI Responses API as a callable function tool without building a full integration. Here is the workflow:

1. Write the function schema. OpenAI's function-calling API accepts a JSON schema describing your function's name, description, and parameters. Write one that maps to your API's endpoint and inputs. The description is the most important field — the model reads it to decide when to call the function, so be specific about the use case.
2. Add it to your API call. Pass the schema in the tools array of your Responses API or Chat Completions call. The model will invoke your function when it determines it is relevant.
3. Handle the tool call in your application. When the model returns a tool_calls response, extract the arguments, make the actual API request, and return the result back as a tool result message.
4. Test with edge cases. Ask questions that should and should not trigger the tool. Verify it calls correctly when expected and ignores the tool when it is not needed.

You will know it worked when the model selects your tool for the right queries and does not hallucinate calls for irrelevant ones. The skill that makes this reliable is writing precise, specific function descriptions — vague descriptions produce unreliable tool selection.

One Prompt

Use this prompt to generate an OpenAI function tool schema from any API description you paste in:

You are an expert at writing OpenAI function-calling schemas.

I am going to describe an API endpoint. Generate a valid OpenAI function tool definition in JSON format — the kind that goes in the tools array of an OpenAI API call.

Requirements:
- name: short, snake_case, descriptive
- description: one precise sentence explaining what the function does and exactly when the model should call it — be specific about the use case, not generic
- parameters: a JSON Schema object with type, properties (each with type and description), and required

Here is the API endpoint to convert:

[PASTE YOUR API DESCRIPTION HERE — include the endpoint URL, HTTP method, parameters, and what it returns]

Output only the JSON object, no explanation.

Paste this into ChatGPT or the Playground, replace the bracketed section with your actual API description, and you get a copy-paste-ready function schema in seconds. You will know it worked when you add the schema to a real API call and the model selects your tool for the right questions and skips it for everything else.

One Tip

Update PyTorch on Apple Silicon today — the speedup is free and automatic.

PyTorch just removed the CPU fallback gate for small SVD operations on Apple's MPS back-end. If you do any local fine-tuning, run PCA, or use LoRA on a Mac with Apple Silicon (M1 through M4), small matrix operations now stay on the GPU chip instead of quietly bouncing to the CPU. No code change needed. Run pip install --upgrade torch to get the update. Verify MPS is active with import torch; print(torch.backends.mps.is_available()) — it should return True. That single update gives you a real speedup on every small-matrix operation in your workflow.

Tool of the Day

legacy2mcp — github.com/bvenkata/legacy2mcp

What it is genuinely good for: wiring an AI agent to any enterprise SOAP web service without rewriting the underlying system. You point it at a WSDL schema file, it generates MCP tool definitions, and at runtime it handles the full SOAP-to-JSON translation transparently — the agent never touches XML directly.

Honest limits: this is an early-stage open-source project. Expect rough edges on malformed or non-standard WSDL files. Error handling is minimal. Best suited for internal proofs-of-concept and automation experiments before committing it to a production path. Test it first on a non-critical SOAP service where a failure has low stakes. If it works there, expand carefully.

Signature Bites

• The SOAP wall is down. legacy2mcp turns decades of stranded enterprise logic into callable AI tools — without a single line of rewrite.
• Deepfake detectors just got harder to fool. SNAP closes the speaker-identity evasion vector that attackers were exploiting.
• Interpretability got a scalpel. The influence score maps which transformer attention heads drove any prediction — analytically, in one pass.
• The energy trade is the new chip trade. Wall Street is pricing nuclear power as critical AI infrastructure — the 23.7% NuScale call is the clearest signal yet.

Joke of the Day

Why did the AI agent refuse to process the SOAP request?

It said the payload was too lathered in XML and it could not find the signal through all the foam.

Fact of the Day

SOAP (Simple Object Access Protocol) was first submitted as a W3C Note. More than two decades later, Large enterprises still commonly operate at least one mission-critical SOAP service in production. That is the scale of what today's lead story is reaching into — not a niche legacy problem, but the operating infrastructure of most large enterprises on earth.

Stat That Matters

23.7% — the projected upside on NuScale Power over eleven months, according to a Wall Street analyst call published this week.

Why it matters: this is not a speculative energy bet. It is the market pricing a real infrastructure bottleneck. AI data centres need power that is always on, carbon-free, and independent of a grid that cannot scale fast enough. Small modular reactors are the only technology that credibly delivers all three on a planning horizon hyperscalers actually care about. When infrastructure analysts start moving SMR stocks on AI demand signals, the energy-compute intersection has officially become an investable thesis, not a conference talking point.

Trends

Three lanes dominated today's scored stories: agentic AI, funding, and frontier research. The agentic-AI signal has been the largest lane consistently — and today's lead story crystallises exactly why: the bottleneck for enterprise agentic adoption is not model capability, it is connectivity. Legacy systems, SOAP endpoints, and proprietary back-ends are the last wall. The funding lane reflects investor appetite shifting toward infrastructure plays, not just application bets. And frontier research is increasingly focused on practical engineering problems — interpretability tools you can actually use in a debugging session, privacy math that holds in a regulated production environment — rather than pure capability benchmarks.

Bold Prediction

Within 18 months, every major enterprise agent platform — including the OpenAI Assistants and Responses API ecosystem — will either ship a native SOAP/WSDL adapter or certify one from an official partner. The legacy2mcp proof-of-concept published today demonstrates that the technical problem is solved. Once a working answer exists, markets formalise around it quickly. The enterprise connectivity layer will become a standard feature of agent platforms, not an afterthought. Falsifiable check: look for official SOAP adapter announcements from at least two major agent platforms by Q1 2028.

Paper Watch

SNAP: Speaker Nulling for Artifact Projection in Speech Deepfake Detection (arXiv:2603.20686)

Most audio deepfake detectors are trained on datasets containing real and synthetic speech from specific speakers. The problem: the model inadvertently learns to flag audio based on speaker identity, not just the presence of synthesis artifacts. An attacker who knows which speakers are in the training set can construct synthetic audio that evades detection by mimicking a familiar voice in precisely the right way — the detector sees a known voice and does not flag it. SNAP addresses this by introducing a speaker-nulling step during detector training: it strips speaker-identity information from the feature representations the detector uses, forcing it to rely only on genuine synthesis fingerprints that cannot be spoofed by voice selection. The result is a detector that generalises better across unseen speakers and is meaningfully harder to evade. Directly applicable to voice authentication, fraud detection, and compliance recording pipelines.

Founder Spotlight

The engineer behind legacy2mcp (GitHub: bvenkata)

Building a SOAP-to-MCP adapter is not a glamorous open-source project — it solves a problem most AI researchers have no interest in and most enterprise developers have been quietly suffering with for years. That is precisely what makes it worth spotlighting. The strategic move here is identifying a connectivity gap between the AI-native world and the legacy-enterprise world, building the bridge, and open-sourcing it before anyone else does. If this project gains traction — and given the scale of enterprise SOAP infrastructure, the pull is obvious — the author is positioned as the person who solved one of enterprise AI's most persistent friction points. This is how category-defining developer tools get their start: one unglamorous, extremely useful adapter that everyone who hits the problem immediately installs.

Quote

'Recent advancements in text-to-speech technologies enable generating high-fidelity synthetic speech nearly indistinguishable from real human voice.'

— SNAP paper abstract (arXiv:2603.20686). The arms race in synthetic speech is real, it is accelerating, and the defensive side just gained a meaningful tool. Read the full paper before you trust any voice-based authentication or fraud detection system you currently have in production.

Learner's Edge

Concept: Model Context Protocol (MCP)

MCP is an open standard now gaining multi-vendor adoption. — that defines how AI agents discover and call external tools. Think of it as the protocol layer between a language model and everything outside it: files, databases, APIs, third-party services.

Before MCP, every agent framework invented its own tool-calling convention. OpenAI's function-calling schema works one way, LangChain's tool interface works another, custom frameworks yet another. This fragmentation meant that every tool you built was coupled to a specific framework. MCP standardises the interface: a tool exposes itself once via a defined server protocol, and any MCP-compatible agent runtime can discover and call it without custom glue code.

Why it matters for your work: as the OpenAI ecosystem moves toward MCP compatibility, any tool you build to the MCP standard today will work with a growing number of agent runtimes tomorrow — without rewriting the integration each time. Today's legacy2mcp story is a direct example: the adapter outputs MCP tool definitions, making a SOAP service instantly reachable by any MCP-compatible agent, regardless of which model or framework is powering the agent. Build once, reach every compatible runtime.

Sign-off

That is The Agent Signal for September 7th. Tomorrow we are watching whether legacy2mcp gains enterprise traction — and whether the SNAP deepfake detection technique starts showing up in production voice-security tooling. Stay sharp and stay practical.

Sources

1. I made legacy SOAP APIs usable by AI agents — github.com
2. SNAP: Speaker Nulling for Artifact Projection in Speech Deepfake Detection — arxiv.org
3. Influence Score and Transformers interpretability: Measure of the Effective Impact of Attention Heads at inference time — arxiv.org
4. Faster Learning under Relaxed Local Differential Privacy — arxiv.org
5. NuScale Power Stock Will Spike 23.7% Over the Next 11 Months According to This Wall Street Analyst — Motley Fool
6. Nordics leaderboard: the data behind the region’s fastest-growing startups — sifted.eu
7. trunk/4144bea4b7c2f67da9d4840f4659f977bbd754e5: [MPS] Remove svd_kernel_mps small-input CPU gate (#195950) — github.com
8. c2cgeoportal-admin 2.8.1.379 — pypi.org