Developers

Natural language in, tool calls out

Describe your API. Fernfly writes the training data, fine-tunes a small model on your tool set, and gives you an endpoint that returns the call. Put the intent bar in front of it, or call it from your own code.

POST /api/p/YOUR_PROJECT_ID/infer
// a sentence in
“move my 3pm standup to Thursday”
// a tool call out
reschedule_event({
event: "Standup",
to: "2026-07-09T15:00"
})

Add the intent bar

The SDK is @fernfly/intent-bar on npm: a React component, or a script tag for apps that don’t use React. It is early, and its API may change before 1.0.

  1. aTrain a projectPoint Studio at your API docs or an OpenAPI file, approve the examples it writes, and train.
  2. bAllow your appOn the project page, allow keyless calls and add your app’s address to the allowed sites.
  3. cAdd the barPass the project id to the component or the script tag, and handle each tool in your own code.
React · npm install @fernfly/intent-bar
'use client'
import { IntentBar } from '@fernfly/intent-bar'

export function AppIntentBar() {
  return (
    <IntentBar
      project="YOUR_PROJECT_ID"
      appName="Acme"
      tools={{
        list_invoices: {
          kind: 'filter',
          run: (args) => router.push(invoicesUrl(args)),
        },
      }}
    />
  )
}
Script tag
<script
  src="https://cdn.jsdelivr.net/npm/@fernfly/intent-bar@VERSION/dist/intent-bar.global.js"
  integrity="sha384-…"
  crossorigin="anonymous"
  data-project="YOUR_PROJECT_ID"
></script>

Pin the version, and copy the integrity hash from that release’s notes. The file includes React, so the page needs nothing else.

One endpoint, one shape

Post a sentence. Get back the calls to run, in the order to run them, or an empty list when the model declines rather than guesses. That is the whole surface.

Request
POST /api/p/YOUR_PROJECT_ID/infer
X-Api-Key: YOUR_PROJECT_KEY
Content-Type: application/json

{
  "utterance": "move my 3pm standup to Thursday",
  "meta": { "user_id": "u_1042" }
}
Response
{
  "calls": [
    {
      "name": "reschedule_event",
      "arguments": {
        "event": "Standup",
        "to": "2026-07-09T15:00"
      }
    }
  ]
}

Why not just prompt a frontier model

You can, and for a handful of calls a day you probably should. The economics invert once the same bounded intent runs thousands of times: a general model re-reads your entire tool schema on every call, and you pay for those tokens every time.

  1. aThe schema is not re-sentTools are registered once and referenced by id. A frontier call pays for the full spec as input tokens on every request.
  2. bOne hop, not a planIntent to action is a single classification with arguments. No planning loop, no chain of thought, no retry budget.
  3. cSmall enough to sit anywhereA 12M-parameter model can run on ordinary CPU hardware, which is what makes on-premises and offline deployment possible at all.

Do not take the claim on trust. The playground runs the same curated tasks through a Fern model and through GPT-4o side by side, and reports accuracy, schema conformance, latency and the frontier cost per run.

What happens after you click train

  1. aRegister the toolsYour tool schema is uploaded once and content-addressed to a tool_set_id. Training lines and inference calls then reference the id instead of re-sending tens of KB of JSON Schema on every request.
  2. bGenerate the training setGemini writes candidate utterance-to-call pairs from your schema, including negatives for anything out of scope. You review, edit and approve them before they become training data.
  3. cFine-tuneApproved pairs become JSONL and a fine-tuning job on the Fern inference API. Epochs, batch size and learning rate default from a pair-count heuristic and can be set explicitly.
  4. dDeploy and versionA deployment pins one fine-tuned model id. The stable per-project endpoint always routes to the active deployment; the per-deployment endpoint pins a version, so you can hold traffic on a known-good model while you retrain.

Three base models, all fine-tunable

Fern Bud

Size
12M parameters
Model id
fern-bud-1.0

Where a project starts unless you say otherwise. Trains in minutes.

Fern Pinnule

Size
160M parameters
Model id
fern-160m

More accurate once the tool set grows past what a 12M model holds comfortably. Slower to train and slower to answer.

Fern Pinna

Size
1.5B parameters
Model id
fern-1500

The accuracy ceiling, and what our own templates train on. Slowest to train and to answer.

Base model, epochs, batch size and learning rate all default from the size of your approved training set, and the wizard pre-fills them. Set them explicitly if you have a reason to. They are fixed once the project has trained, so a retrain reproduces the same configuration.

Three ways to put it in front of users

The intent bar

A React component or a script tag. It calls the keyless endpoint from your users’ browsers, limited to the sites you allow, and your app runs each call.

For a web app

Your own backend

POST the sentence with a project key, get the call back, and run it yourself against your API with your own auth and permissions.

For a support desk, a workflow or an agent

Inside your network

The model is small enough to run on your hardware, so requests never leave the building. Talk to us about a private deployment.

For regulated data

What it does at the edges

  • Out-of-scope sentences resolve to a sentinel rather than a wrong call, so your app never receives a tool you did not train.
  • An empty call list is a first-class answer. The model declining is a better outcome than a plausible guess.
  • A cloud fallback can answer anything the model declines, and it is a per-project switch you own.
  • Job status is pulled live from the training backend, so a run that fails upstream shows in your dashboard rather than hanging.

Who may call, and how often

  1. aTwo auth modesServer-to-server with a project API key, or keyless for the intent bar in the browser. Key-authed traffic skips the origin check and the rate limit; keyless traffic gets both.
  2. bOrigin allow-listA keyless project answers only the sites you list, and the CORS grant reflects the caller instead of a wildcard. Requests with no Origin header fall through to the rate limit, since Origin is trivially forged outside a browser.
  3. cPer-caller rate limit20 requests a minute per caller per project on the keyless endpoint, counted in the database so the window is shared across workers and survives a reload.
  4. dEvery call loggedLatency, the resolved call, the fallback path and a salted caller hash. The analytics tab rolls it up; the history tab lists it one row at a time.

One we built and shipped

Hoobert is a ⌘K command bar for WooCommerce, live on the WordPress.org plugin directory. It is an ordinary Fernfly project: 28 store actions, one endpoint, and a plugin that runs the returned call through the WooCommerce REST API with the shop manager’s own permissions.

Your traffic is the next training set

Every request is logged with what the model resolved it to. The ones it declined, and the chips your users corrected, are collected for review. Approve them, retrain, and cut a new deployment. The previous version keeps serving until you switch, so the endpoint is never down.

Point it at your API

Free plan, no card, and the first endpoint is live in an afternoon.