New: Introducing the Lemma MCP Server, and what we learned building it.New: Introducing the Lemma MCP Server. Read the blog post

Skip to main content

Thousands of Functions, Ready to Call.Add Your Own.

The function catalog holds every action your Workers and agents can take in your systems. It ships with thousands of ready-made functions, and any API you own can join them. Each one is versioned and access-controlled once, then reused safely everywhere, with every call on the record.

The Whole Business, One Call Away.

Ready-made or your own, every function in the catalog is called, governed and recorded the same way. That is what lets your Workers and agents act anywhere in the business, under one set of rules.

Ready to call

Thousands of functions, ready on day one.

Every integration Lemma ships with arrives as functions: get an account, post a message, load a table. Systems of record, messaging, data platforms, identity and model providers are already covered, so your team starts building instead of writing integrations.

Ready-made integrations
Every operation already a function
One search
Filter by what a function does and who may call it
Yours included
Beside Salesforce and Slack, and just like them
Modern and legacy

New and old systems, in one catalog.

Your newest cloud tools and your oldest systems of record sit side by side. Call a SaaS API, reach an on-premises system through its own API inside your network, query a database directly, or wrap anything else in a few lines of code. One Worker can mix them freely, under one set of rules.

  • Cloud and on-premises systems in the same Worker
  • Private systems reached over mTLS, inside your network
  • Databases and your own code beside your APIs
  • One set of permissions and one record for all of them
Protocols

REST, gRPC, GraphQL. One kind of call.

Bring the API definition you already have: an OpenAPI document, a gRPC service or a GraphQL schema. The catalog turns each operation into a function with typed inputs and outputs, so a Worker never has to care which protocol sits underneath.

SOAP, coming soon
Your APIs

Your own APIs, treated like the rest.

Register your inventory service, pricing engine or claims system, and its operations become functions with the same versioning, permissions and record as everything else. An integration holds the credential, and private endpoints are reached over mTLS.

One URL
Point the catalog at an OpenAPI document and every operation is listed.
Inside your network
Private endpoints over mTLS, through an integration you control.
Owned by your team
Release versions on your schedule, and see every caller before you retire one.
Code and data

No API? Write the step, or the query.

Not everything has an API. Write a function in Python or Node.js, or a database query with typed parameters, and it joins the catalog beside your APIs, versioned and governed like them.

  • Python and Node.js, run inside Lemma
  • SQL with typed parameters, read or write by permission
  • Versioned and governed like your APIs
Agents

Hand an agent exactly the tools it needs.

An agent’s tools come straight from the catalog. Each function describes itself to the agent, the agent sees only the functions it is allowed to use, and every call is recorded. Give it three functions and it has three tools, no more.

Described for you
Tool names, descriptions and parameters come from the registered function.
Enforced in the runtime
A function outside the agent’s grant never appears in its tool list.
On the record
Which tool, which version, what went in and what came back.
Identity and access

Know who is behind every call.

Every call runs under an identity you can name, human or not. A function can use a credential your team holds, each person’s own sign-in or, where enabled, one chosen during the run. Service accounts give a Worker only the access it needs, and every call keeps who started it and whose access it used.

People
A call made with a person’s own sign-in carries that person’s access, and nothing more.
Service accounts
Non-human identities granted specific Workers, with credentials that expire and can be revoked.
Agents
No identity of their own: they act only through the functions and credentials they are given.
Observability

See how every function performs.

Track calls, latency, errors and callers for each function and each version. The same data flows to your own tools through OpenTelemetry, so the catalog adds to the monitoring you run instead of replacing it.

Configuration

The hard parts of calling an API, handled.

Set retries, timeouts, pagination, rate limits, mTLS and step-up authentication once on the function, and Lemma applies them on every call. No team has to rebuild them, and no team gets them slightly wrong.

  • An idempotency key on every call, so a retry never does the work twice
  • Cursor, offset or page token, followed to the last page
  • mTLS through an integration, and step-up authentication for sensitive actions

Register It Once.Use It Everywhere.

Without a catalog, every team wraps the same APIs its own way, and every agent needs its own review. With one, each function is defined, access-controlled and versioned once, then reused by every Worker and agent in the workspace.

See Your APIs in the Catalog.

Walk through the function catalog with our team, using your own systems.

Request a Demo