SPEAKER_1: Last time we covered bulk operations—agents working across connected sites without losing structural footing. Now I want to get into what makes all of that possible at the design level. The 'Verbs, Not Endpoints' philosophy. What is that actually saying? SPEAKER_2: The key idea is about what the agent sees when it reaches for a tool. A traditional REST API exposes endpoints—URLs that map to data. The agent has to know which endpoint to call, how to format the request, what parameters to pass. That's a lot of implementation detail the agent has to carry. SPEAKER_1: And that's where things break down? SPEAKER_2: Exactly. When an agent composes raw API requests on the fly, it can hallucinate endpoint structures—inventing paths or parameters that don't exist. The request fails silently, or hits the wrong resource entirely. That's a brittle integration by design. SPEAKER_1: So instead of endpoints, Respira exposes verbs. Operations like 'publish post' or 'update hero section'—things that map to intent rather than transport details. SPEAKER_2: Precisely. The agent chooses from explicit, named workflows. 'Create post.' 'Assign taxonomy.' 'Update media metadata.' Each verb maps to a defined action with validated inputs. The agent doesn't need to know how WordPress stores that data internally—it just calls the right verb. SPEAKER_1: For someone who's worked with REST APIs before, that might feel counterintuitive. Developers are trained to think in endpoints. Why does hiding that layer actually help? SPEAKER_2: Because the agent isn't a developer—it's a reasoning system choosing from a vocabulary. A smaller, more action-oriented vocabulary is easier to reason over than an open-ended space of possible HTTP calls. Surprisingly, many agent integrations become simpler when the tool vocabulary is smaller, not larger. SPEAKER_1: So the reliability gain comes from constraining the choice space. SPEAKER_2: That, and auditability. High-level actions are easier to audit than arbitrary low-level API calls. A raw POST request to a nested endpoint is not. SPEAKER_1: That connects directly to lecture two—the architecture has to earn trust. Logging and observability aren't optional. SPEAKER_2: Same principle exactly. And verb-based design makes permission management cleaner too. Each verb can map to a distinct policy. 'Publish' requires one permission level. 'Delete' requires another. Role-based access control becomes legible when the actions themselves are named and bounded. SPEAKER_1: Let's focus on the architectural benefits of using verbs. The verb-based path allows the agent to call operations like 'update post content' with necessary field values, while Respira handles serialization, authentication, and validation. This simplifies the agent's task to expressing intent, enhancing reliability and reducing errors. SPEAKER_1: The system's design ensures safe failure. The server validates inputs before executing actions, rejecting unauthorized or out-of-scope operations cleanly. This server-side mediation enhances reliability and security. SPEAKER_1: Now, the takeaway here isn't that endpoints disappear entirely. There's still a role for them, right? SPEAKER_2: Important nuance. The strongest agent designs often combine verbs for execution with endpoints for inspection and diagnostics. Think of it this way: a verb publishes the post; a read endpoint verifies the result. They're complementary. The verb layer handles intent; the endpoint layer handles observation. SPEAKER_1: So for someone managing a complex WordPress portfolio, the practical shift is this: instead of teaching an agent the internal plumbing of twelve different builders, the agent learns one shared action vocabulary that works across all of them. SPEAKER_2: That's the architectural argument in one sentence. The interface models intent and action, not data retrieval. The agent can stay reliable across heterogeneous stacks without relearning the plumbing each time. The verb stays the same. Respira handles what's underneath. For everyone following this course, the takeaway is precise: high-level verbs can make AI agents more reliable, more auditable, and easier to direct—because the agent chooses from a vocabulary of intent instead of composing requests from scratch.