Latitude 10 Agentify API for Scala (Play)

What is the Latitude 10 Agentify API for Scala (Play)?

Agents need to find your API, understand it, call it and maybe pay for it. That usually means writing an MCP server by hand, learning which discovery files agents look for, and deciding how to meter them. Agentify does it from the OpenAPI document you already have (a file, the one your app serves, or play-swagger’s), inside the app you already run: there is no second server to deploy.

A Play 3.0 module for Scala 2.13 and Scala 3 apps, on the core of Agentify API for Java, and an sbt plugin. With Guice there is no code to add: the module puts its filter right after Play’s host and CORS filters, and an agent’s tool call runs through your own router, filters and actions, so your auth, action builders, validation and business logic are the ones already tested. It runs on Pekko HTTP and Netty, with Guice or compile-time DI. A readiness check tells you what a model will get wrong about your API before an agent does. It is the Scala edition of Agentify API for Node.js: the same documents, the same wire formats, the same readiness score. Code you own; Java 17 or newer and a Play 3.0 app built with sbt 1.x, with an OpenAPI document, and a database for keys and usage: SQLite, Postgres or MySQL/MariaDB.

Agentify comes hosted or self-hosted. This kit is the self-hosted edition, inside the app you run. The hosted edition serves the same tools from your OpenAPI spec at a URL on latitude10.tech, free in a Latitude 10 workspace.

Want it installed for you? Ask for a fixed-price quote on the contact page.

You run this code and are responsible for it: review it, test it on staging, and check that it meets the laws, platform rules and security standards that apply to you before production. It is not legal, compliance or financial advice, and using it doesn’t make Latitude 10 your payment processor or service provider.

What do you get?

• An MCP endpoint (both MCP versions) with one tool per operation: reads on, writes off until you turn them on
• Tool calls run in-process through your own router, filters and actions: your action builders and error handler included
• Discovery from one document: llms.txt, the MCP server card, OpenAPI with agent hints, OAuth metadata, /.well-known/x402 and an /agent index, in the Node.js edition’s wire formats
• An agent-readiness score from 0 to 100 with fixes, the same score as the Node.js edition, and a command that drafts better descriptions
• No OpenAPI document yet? sbt "agentify draft" says how to add play-swagger, which makes one from your routes file
• Agents use your API’s own credentials, agent keys, or OAuth; rate limits and usage metering for agent traffic
• Optional x402 pay-per-call for agents, settled only when your route succeeds; people with their own keys are never charged
• Pekko HTTP or Netty, Guice or compile-time DI; a SQLite file, your app’s own Play database, or a Postgres, MySQL or MariaDB store

Every kit includes

• The full source code, yours to change
• A setup wizard: node setup.mjs, uv run setup.py for Python, dotnet run setup.cs for .NET, java Setup.java for Java, ruby setup.rb --demo for Ruby, php setup.php --demo for PHP, or java Setup.java --demo for Scala
• A versioned release with a changelog
• A download link that always serves the latest release

What's new in v1.0.0

• First release of the Agentify API for Scala (Play): a Play 3.0 module, tech.latitude10 %% agentify-play, for Scala 2.13 and Scala 3 apps (Scala and Java API controllers) on Java 17, 21 and 25, on…
• An MCP endpoint (both protocol eras) with a tool per operation, run in-process through your own router, filters, action builders and error handler, and discovery documents: /llms.txt, server card,…
• On your routes: agent detection, agent keys, OAuth, rate limits, usage metering, x402 pay-per-call and Idempotency-Key. Settings in an agentify block in HOCON (conf/agentify.conf), with secrets…
• sbt "agentify <command>", an sbt plugin that runs the kit's CLI: init writes agentify.sbt, project/agentify-plugin.sbt (the vendored repository first in fullResolvers) and…
• A setup wizard (java Setup.java) that vendors the kit into your sbt build and updates it (--update: every Play app of the build, at any depth, rolled back on any failure, its backup kept and named…

What's in the zip

• latitude10-agentify-api-scala/
• latitude10-agentify-api-scala/CHANGELOG.md
• latitude10-agentify-api-scala/LICENSE.md
• latitude10-agentify-api-scala/README.md
• latitude10-agentify-api-scala/Setup.java
• latitude10-agentify-api-scala/THIRD-PARTY-NOTICES.md
• latitude10-agentify-api-scala/VERSION
• latitude10-agentify-api-scala/agentify.jar
• latitude10-agentify-api-scala/examples/
• latitude10-agentify-api-scala/lib/
• latitude10-agentify-api-scala/repository/

How do you set it up?

Makes a bundled Play 3 Orders API in Scala agent-ready behind its own API-key action builder, with no API key and no wallet: installs the kit into a copy of it, scores its thin spec (54/100) and improves it to 96, builds it with sbt stage and starts it, serves every discovery document, connects an MCP client in both versions, calls a tool through the API’s own auth, rate-limits an agent key, takes an x402 payment and prints the usage.

You'll need: Java 17 or newer and a Play 3.0 app (PlayScala or PlayJava) in Scala 2.13 or Scala 3, built with sbt 1.x, on Pekko HTTP or Netty. An OpenAPI document: a file, the one your app serves, or play-swagger’s (sbt "agentify draft" says how to add it). Keys and usage live in a SQLite file by default, or in your app’s own Play database or a store of its own: SQLite, Postgres or MySQL/MariaDB, with its JDBC driver. The wizard needs only Java; installing into your app also needs sbt, and the demo needs Maven Central to build its Play. Optional: an OAuth provider, a wallet address for x402.