​

What is Inferable?

Inferable is a managed developer platform that makes it easy to build reliable, secure, agentic LLM-based applications.

We provide a set of tools and sensible defaults to let developers focus on building their applications, without having to configure infrastructure or do LLM-specific plumbing.

​

🔨 Distributed Tool Calling

Functions within your code are registered using one of the Inferable SDKs, this makes the function available as a tool for the agent to use within Runs.

The execution of functions takes place within your environment. Inferable manages a job queue of function calls which is polled by the SDK. This means in order to use a function,

1. Your service does not need to expose an endpoint to receive function calls.
2. There are no network configuration changes required to run the function.
3. The function will be executed in your own VPC, as long as it can connect to the Inferable cluster.

• TypeScript
• Go
• .NET

inferable.default.register({
  name: "submitTicket",
  description: "Submit a support ticket",
  func: (input) => {
    console.log("Submitting support ticket", input);
    return `Ticket submitted for ${input.userName}`;
  },
  schema: {
    input: z.object({
      userName: z.string(),
      userEmail: z.string(),
      issue: z.string(),
    }),
  },
});

The snippet above registered a function submitTicket with the default service. Agents within the same cluster can now invoke this function as needed.

This architecture separates the agent runtime from the function execution and allows us to support multiple languages. We currently support NodeJS, Go and .Net.

​

🤖 Managed Agent Runtime

When inferable receives a new Run, it is executed using a ReAct-like agent strategy which iteratively reasons about the task and takes actions to achieve the requested outcome. This includes calling the attached functions as necessary.

Inferable performs all model calls and gracefully handles transient errors such as timeouts. The Run is a durable execution construct which supports indefinitely long Function calls and pausing for human interaction.

• TypeScript
• Go
• .NET
• CLI
• cURL
• Playground

const run = await inferable.run({
  initialPrompt: `Submit a support ticket with these details: ${details}`,
  attachedFunctions: [
    {
      function: "submitTicket",
      service: "default",
    },
    {
      function: "sendEmail",
      service: "default",
    },
    // ... Any other functions to make available to the run
  ],
  resultSchema: z.object({
    success: z.boolean(),
  }),
  // Optional: Subscribe an Inferable function to receive notifications when the run status changes
  // onStatusChange: { function: { function: "handler", service: "default" } },
});

​

💬 Persistent Chat State

An Inferable Run persists state including any previous messages and function calls. This makes it easy to build AI applications that need to pause for an indeterminate period of time. This could include:

• Awaiting User input
• Executing Arbitrarily long function calls

Runs can be continued with additional messages, without needing to pass the entire message history into the API call.

​

💻 Front End API usage

Inferable’s API’s can be called from front end application directly by using a Customer Provided Secret and verification function. This makes it possible to safely build AI applications without hosting an API server.

​

Learn More