Dev Proxy: Declarative Agents, No API

Key insights

• Dev Proxy demo overview: This session shows how Dev Proxy helps you build and test declarative agents when no live API exists.
  Presenter Garry Trinder walks through a practical restaurant agent sample and common development scenarios.
  
• API simulation: Dev Proxy returns mocked CRUD data and can simulate authentication, delays, throttling, and error responses so you can test realistic failure modes.
  This lets you validate agent logic beyond the happy path without a backend.
  
• How it runs: Dev Proxy runs locally as a command-line tool and can register as the system proxy to intercept matching requests.
  You configure URL patterns and response behaviors, then run your app normally to see simulated outcomes.
  
• Benefits for agents: Use Dev Proxy to prototype flows earlier, test error handling, and build resilience before services are ready.
  Developers can iterate faster without changing application code or waiting on backend deliverables.
  
• Demo features: The sample shows validating Entra SSO tokens, simulating API-key and OAuth flows, and routing calls through a dev tunnel to mimic external paths.
  It highlights testing authentication, latency, throttling, and error scenarios during development.
  
• Practical tips: Use mocked responses to exercise edge cases and include these tests in early CI checks.
  If interception fails, verify Dev Proxy is running, URL patterns match your requests, and the system proxy registration is active.
  

Overview of the Demo

Microsoft published a YouTube demo titled "No API, No Problem: Building Declarative Agents with Dev Proxy" that shows how developers can keep agent development moving without a live backend. In the session, Garry Trinder demonstrates a restaurant agent sample that uses Dev Proxy to simulate an API, route requests through a dev tunnel, and validate Entra SSO tokens. He also returns mocked CRUD data and tests behaviors such as authentication, latency, throttling, and error responses. Therefore, the video gives a practical walkthrough for building and testing before a real API exists.

How Dev Proxy Works in Practice

Dev Proxy runs locally and acts as a command-line web proxy that intercepts requests on a developer's machine. It can register as the system proxy so that matching requests are routed automatically through the simulator, making it simple to run your app unchanged while Dev Proxy supplies responses. During the demo, the tool stands in for backend endpoints and mimics real-world conditions so the agent can be exercised end to end. As a result, developers can validate request handling and tool integration early in the development cycle.

The demo also highlights use of a dev tunnel to expose local endpoints for broader testing and collaboration. This approach enables remote testing and integration with external tools without deploying a real backend, which speeds up feedback loops. Additionally, the demo shows token validation for Entra SSO, so the simulated environment can include realistic authentication flows. Thus, the proxy supports both functionality and security testing in a controlled, local context.

Benefits for Declarative Agents

For teams building declarative agents, the main advantage is early iteration. By simulating API responses and error modes, teams can prototype agent decision logic and tool integrations before backend contracts stabilize. Consequently, this reduces idle time for frontend and agent developers while backend work continues in parallel. Moreover, realistic failure modes let developers tune retry logic and fallback behavior rather than waiting to discover these needs in production.

Another practical benefit is resilience testing: developers can inject delays, rate limits, and errors to see how the agent reacts. This helps uncover brittle assumptions and improves overall robustness of the agent. Since the application code does not need modification to use the proxy, testing stays closer to production behavior. Therefore, teams can iterate faster while maintaining higher confidence in reliability.

Tradeoffs and Development Challenges

Although simulated APIs speed up development, they introduce tradeoffs that teams must manage. For example, a mock can drift from the real API contract over time, which risks false confidence and integration surprises later. To mitigate this, teams must plan regular synchronization between mocks and actual API specifications or adopt contract-driven testing practices. Otherwise, the benefit of fast iteration can be undermined by increased integration effort downstream.

Security and authenticity present additional challenges when simulating authentication like Entra SSO. While Dev Proxy can validate tokens and emulate auth flows, it cannot perfectly reproduce all edge cases a production identity provider might present. Therefore, teams should treat simulated auth as one layer of testing and still perform end-to-end validation against real identity services before release. Finally, simulated latency and throttling help surface resilience needs, but they may not capture complex, distributed behaviors found in production systems.

Operational Considerations and Best Practices

To get the most value from this approach, developers should balance the speed of local simulation with periodic, real API tests. For example, integrate Dev Proxy scenarios into continuous integration pipelines and complement them with smoke tests against staging or sandbox environments. This hybrid strategy reduces the risk of drift while keeping fast feedback loops for agent logic. Likewise, document and version mock configurations so teams share a consistent simulated environment.

Teams should also be deliberate about which behaviors to simulate and when to switch to real endpoints. Simulating common error modes and authentication flows early is high value, whereas overspecifying resource-heavy or rare production behaviors may waste effort. In addition, involve backend owners in creating and reviewing mocks to align on expected contract changes. Consequently, a collaborative approach ensures smoother handoffs and fewer surprises when real APIs arrive.

Practical Takeaways

The Microsoft demo provides a clear path for building declarative agents without waiting for a complete backend. It shows how Dev Proxy can simulate endpoints, validate tokens, and emulate network conditions so developers can test and iterate quickly. However, teams must still manage mock drift, validate security with real identity providers, and schedule integration tests against real services. By combining local simulation with periodic real-environment checks, teams can enjoy faster development while preserving reliability.

In summary, the video demonstrates a pragmatic toolkit for accelerating agent development and improving resilience testing. With careful practices around synchronization, authentication validation, and test coverage, organizations can leverage Dev Proxy to minimize blockers and build more robust agents. Ultimately, this balanced approach enables faster innovation while reducing late-stage surprises.

Related Resources

• Development
• Developer

Keywords

declarative agents, Dev Proxy, API-less agents, no API agents, agent orchestration, building declarative agents, developer proxy patterns, low-code AI agents