{"id":35181,"date":"2026-10-25T21:47:19","date_gmt":"2026-10-25T20:47:19","guid":{"rendered":"https:\/\/www.angulararchitects.io\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/"},"modified":"2026-10-26T10:38:09","modified_gmt":"2026-10-26T09:38:09","slug":"clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting","status":"publish","type":"post","link":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/","title":{"rendered":"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting"},"content":{"rendered":"<div class=\"wp-post-series-box series-compact-and-system-one-models wp-post-series-box--expandable\">\n\t\t\t<input id=\"collapsible-series-compact-and-system-one-models6adf333252dda\" class=\"wp-post-series-box__toggle_checkbox\" type=\"checkbox\">\n\t\n\t<label\n\t\tclass=\"wp-post-series-box__label\"\n\t\t\t\t\tfor=\"collapsible-series-compact-and-system-one-models6adf333252dda\"\n\t\t\ttabindex=\"0\"\n\t\t\t\t>\n\t\t<p class=\"wp-post-series-box__name wp-post-series-name\">\n\t\t\tThis is post 2 of 2 in the series <em>&ldquo;Compact and System One Models&rdquo;<\/em>\t\t<\/p>\n\t\t\t<\/label>\n\n\t\t\t<div class=\"wp-post-series-box__posts\">\n\t\t\t<ol>\n\t\t\t\t\t\t\t\t\t<li><a href=\"https:\/\/www.angulararchitects.io\/en\/blog\/using-jev-for-agentic-ui-just-a-trend-or-a-game-changer\/\">Using Jev for Agentic UI: Just a Trend or a Game Changer?<\/a><\/li>\n\t\t\t\t\t\t\t\t\t<li><span class=\"wp-post-series-box__current\">Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting<\/span><\/li>\n\t\t\t\t\t\t\t<\/ol>\n\t\t<\/div>\n\t<\/div>\n<p><em>Clef selects the tool, Clairic extracts the parameters, and open weights bring the decision part to your own hardware<\/em><\/p>\n<p>In September 2026, Jev caused quite a stir. TypeSafe presented it as the first System One model. Jev does not write text. It answers predefined questions with predefined options, typically within a few hundred milliseconds. In the <a href=\"https:\/\/artificialanalysis.ai\/articles\/artificial-analysis-decision-index\">Decision Index<\/a> by Artificial Analysis, it scores in the range of fast LLMs but needs only a fraction of their time. This makes Jev a strong fit for decisions inside an Agentic UI, such as selecting the next tool.<\/p>\n<p>Since October 1, 2026, Cloudflare's Clef offers an open-weight alternative with the same API. Like Jev, however, Clef only classifies. Cloudflare's Clairic, released on October 19, adds extraction. Unlike classic extraction models, it does not only copy values from the text. It also derives and computes values such as the date behind <em>in 10 days<\/em>, and it forecasts how a series continues.<\/p>\n<p>In this article, I combine both models in a flight assistant built with Angular and CopilotKit. Finally, I show how far the road to local hosting already reaches.<\/p>\n<p>\ud83d\udcc2 <a href=\"https:\/\/github.com\/manfredsteyer\/clef-clairic-first-steps\">Source code<\/a><\/p>\n<h2>The Example: Flight Search with Angular and CopilotKit<\/h2>\n<p>The example is the flight search I use to demonstrate all kinds of concepts. In a chat, users ask for flights or for the flights they have booked. The server decides which tool to call, runs it, and streams the result to the client as AG-UI events. CopilotKit renders each flight as a widget. Below each answer, the application reports how long the two models took:<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/01.png\" alt=\"Chat view of the flight assistant: the user asks &quot;Did I already book Paris?&quot;. The assistant calls the tool findBookings and shows the booked flight from Wien to Paris. Below, the metrics: Clef took 614 ms, Clairic 610 ms, and running both models in parallel 626 ms.\" \/><\/p>\n<p>For the question <em>Did I already book Paris?<\/em>, Clef selects the tool <code>findBookings<\/code>. At the same time, Clairic extracts Paris as the destination. The application then shows the booked flight from Wien to Paris.<\/p>\n<h2>Compensating for the Limits of Decision Models<\/h2>\n<p>As my <a href=\"https:\/\/www.angulararchitects.io\/en\/blog\/using-jev-for-agentic-ui-just-a-trend-or-a-game-changer\/\">article on Jev<\/a> shows, a decision model quickly determines the tool to call. However, it only chooses among options you define up front. This applies to Clef as well. Tool parameters therefore have to be options too. This is why the example in that article contained a data structure with all the airports our airline serves. For values such as names, dates, or flight numbers, this approach reaches its limits, because nobody can list all of them in advance.<\/p>\n<p>Clairic closes this gap. The example divides the work as follows:<\/p>\n<ul>\n<li>Clef selects the tool: <code>findFlights<\/code>, <code>findBookings<\/code>, or none. It also answers whether the conversation names the departure, the destination, and the date.<\/li>\n<li>Clairic extracts the parameters: departure, destination, date, and the maximum number of flights.<\/li>\n<li>The server sends the request to both models at the same time.<\/li>\n<\/ul>\n<p>In my tests, Clairic tended to name a city even when the traveller stated none for that end of the journey. It also carried the day of a flight over to its return flight. Hence, the server only takes a departure, destination, or date from Clairic when Clef confirms that the conversation names it. This way, Clef serves as an additional check for Clairic's answers.<\/p>\n<h2>What Are Clef and Clairic?<\/h2>\n<p>Both models come from Cloudflare and run on Workers AI. Clef makes decisions, and Clairic extracts values.<\/p>\n<h3>Clef<\/h3>\n<p>Clef follows the System One API that TypeSafe introduced with Jev. Like Jev, it answers a question by choosing one of several predefined values and returns a probability for each of them. This suits tool calling well. The options are the available tools, so Clef cannot invent a tool, and the application always receives a value it expects. The probabilities show how sure Clef is. As Clef generates no text, it answers quickly. Cloudflare offers Clef in two sizes, Clef with 27B and Clef-flash with 9B parameters, and publishes both under the Apache 2.0 license.<\/p>\n<p>My <a href=\"https:\/\/www.angulararchitects.io\/en\/blog\/using-jev-for-agentic-ui-just-a-trend-or-a-game-changer\/\">article on Jev<\/a> describes this approach in detail. In our example, the function <a href=\"https:\/\/github.com\/manfredsteyer\/clef-clairic-first-steps\/blob\/main\/server\/src\/models\/clef.ts\"><code>evaluate<\/code><\/a> sends the request to Clef.<\/p>\n<h3>Clairic<\/h3>\n<p>Cloudflare calls Clairic the first model of a new class: System One extraction models. Clef and Jev belong to the class of System One decision models. Like them, Clairic does not write text. It receives a state, which consists of text and up to four images, and a set of typed fields. For each field, it returns a typed value.<\/p>\n<p>Clairic supports the following field types:<\/p>\n<ul>\n<li><code>text<\/code> returns a span of the input together with its character offsets.<\/li>\n<li><code>number<\/code> returns a number and respects settings such as <code>integer<\/code> and <code>decimals<\/code>.<\/li>\n<li><code>date<\/code>, <code>time<\/code>, and <code>datetime<\/code> return values in ISO format.<\/li>\n<li><code>duration<\/code> returns a duration in a unit of your choice.<\/li>\n<li><code>list<\/code> returns several text, number, or date items in the order of the input.<\/li>\n<li><code>estimate<\/code> returns a distribution within a declared range, and <code>forecast<\/code> returns one estimate per future step of a series.<\/li>\n<\/ul>\n<p>Clairic does more than copy values from the input. It can also compute them. In Cloudflare's examples, it adds a price and its tax or counts the days between two dates. In our example, it turns expressions such as <em>the day after tomorrow<\/em> or <em>in 10 days<\/em> into a date.<\/p>\n<p>Clairic is available as a preview on Workers AI. Cloudflare names the current limits openly. Multi-step arithmetic is not a strength yet, and every answer is well formed but not necessarily correct.<\/p>\n<h2>Implementation<\/h2>\n<p>The code for Clef is very similar to the code in my article on Jev. The constant <a href=\"https:\/\/github.com\/manfredsteyer\/clef-clairic-first-steps\/blob\/main\/server\/src\/ticketing\/questions.ts\"><code>QUESTIONS<\/code><\/a> contains the questionnaire. It asks which tool the traveller wants and whether the conversation names the departure, the destination, and the date. A value counts as named when Clef's probability exceeds 0.5.<\/p>\n<p>This section therefore focuses on Clairic and on combining both models.<\/p>\n<h3>Describing the Fields<\/h3>\n<p>Clef works with a questionnaire. Clairic's counterpart is a set of fields. The constant <code>FIELDS<\/code> describes the four parameters of the tools:<\/p>\n<pre><code class=\"language-ts\">\/\/ server\/src\/ticketing\/parameters.ts\nimport { normalizeCity } from &#039;..\/data\/cities.ts&#039;;\nimport { extract, type Answer, type Field } from &#039;..\/models\/clairic.ts&#039;;\n\n[...]\n\nconst SAME_ROUTE =\n  &#039; A last message that only changes the day or the number of flights keeps the route from &#039; +\n  &#039;before.&#039;;\n\nconst FIELDS: Record&lt;string, Field&gt; = {\n  from: {\n    type: &#039;text&#039;,\n    instructions:\n      &#039;City the journey starts from, which the traveller asks about in the last message. Earlier &#039; +\n      &#039;messages count only when the last one builds on them: a return flight starts where the &#039; +\n      &#039;flight shown ends.&#039; +\n      SAME_ROUTE,\n  },\n  to: {\n    type: &#039;text&#039;,\n    instructions: [...],\n  },\n  date: {\n    type: &#039;date&#039;,\n    instructions:\n      &#039;Day the traveller wants to fly on, for what they ask about in the last message. Earlier &#039; +\n      &#039;messages count only when the last one builds on them, and a return flight does not take &#039; +\n      &#039;the day of the flight shown. Only a day the traveller states counts.&#039;,\n  },\n  limit: {\n    type: &#039;number&#039;,\n    integer: true,\n    instructions:\n      &#039;How many flights at most the traveller wants to see for what they ask about in the last &#039; +\n      &#039;message. Earlier messages count only when the last one builds on them. Only a number &#039; +\n      &#039;the traveller states for the flights counts.&#039;,\n  },\n};<\/code><\/pre>\n<p>Each field has a type and instructions in plain language. <code>from<\/code> and <code>to<\/code> are text fields. For <code>date<\/code>, Clairic returns an ISO date. The field <code>limit<\/code> expects an integer.<\/p>\n<p>The instructions define what counts. They refer to the last message, as it contains the current request. Earlier messages only count when the last one builds on them, for instance when the traveller asks for the return flight. The sentence <em>Only a day the traveller states counts<\/em> aims to keep Clairic from inventing a date.<\/p>\n<h3>The State<\/h3>\n<p>The state is the input Clairic extracts the values from. Clef accepts any JSON structure as its state, but Clairic expects text. Hence, the function <code>toText<\/code> turns the conversation into a string. A typical state looks like this:<\/p>\n<pre><code class=\"language-text\">Conversation between a traveller and a flight assistant. The last message is the new one.\nToday is Sunday, 2026-10-25.\nTraveller: I am planning a business trip. Could you please show me the connections from Graz to Hamburg?\nAssistant: Flights I found:\nFlights shown: Graz to Hamburg.\nTraveller: Great. And the return flight in 10 days?<\/code><\/pre>\n<p>The first line tells Clairic what the text is about. The second line contains today's date. Clairic uses it to turn relative statements such as <em>in 10 days<\/em> into a date. The conversation follows. For the last answer that showed flights, <code>toText<\/code> adds their routes. This line tells Clairic which route the assistant has shown, so it can derive where a return flight starts and ends.<\/p>\n<p>The server builds the conversation from the AG-UI messages that CopilotKit sends. It considers the last ten entries.<\/p>\n<h3>Calling Clairic<\/h3>\n<p>The function <code>extract<\/code> sends the state and the fields to Clairic:<\/p>\n<pre><code class=\"language-ts\">\/\/ server\/src\/models\/clairic.ts\nconst MODEL = &#039;@cf\/cloudflare\/clairic&#039;;\n\nexport type Field = {\n  type: &#039;text&#039; | &#039;number&#039; | &#039;date&#039;;\n  instructions?: string;\n  integer?: boolean;\n};\n\n[...]\n\nexport async function extract(state: string, fields: Record&lt;string, Field&gt;): Promise&lt;Result&gt; {\n  const accountId = process.env[&#039;CLOUDFLARE_ACCOUNT_ID&#039;];\n  const token = process.env[&#039;CLOUDFLARE_API_TOKEN&#039;];\n\n  const url = <code>https:\/\/api.cloudflare.com\/client\/v4\/accounts\/${accountId}\/ai\/run\/${MODEL}<\/code>;\n\n  const referenceDate = getReferenceDate();\n  const body = JSON.stringify({ model: &#039;clairic&#039;, state, fields, reference_date: referenceDate });\n\n  const response = await fetch(url, {\n    method: &#039;POST&#039;,\n    headers: { &#039;Authorization&#039;: <code>Bearer ${token}<\/code>, &#039;Content-Type&#039;: &#039;application\/json&#039; },\n    body,\n  });\n\n  if (!response.ok) {\n    const reason = await response.text();\n    throw new Error(<code>Clairic answered ${response.status}: ${reason}<\/code>);\n  }\n\n  const json = await response.json();\n  const envelope = json as { result: Result };\n  return envelope.result;\n}<\/code><\/pre>\n<p>Besides the state and the fields, the request contains a reference date. Clairic uses this ISO date for dates written without a year. The account ID and the API token come from environment variables. As the token has to stay secret, this call belongs on the server. Clef runs on Workers AI as well and uses the same keys. Workers AI wraps the answer in an envelope, so <code>extract<\/code> returns its <code>result<\/code> property.<\/p>\n<p>The type <code>Field<\/code> covers the three field types the example needs. The function <code>extractParameters<\/code> calls <code>extract<\/code> with the result of <code>toText<\/code> and the constant <code>FIELDS<\/code>.<\/p>\n<h3>Combining Both Models<\/h3>\n<p>The function <code>decide<\/code> starts both requests at the same time and waits for both answers. The function <code>toAction<\/code> then combines them into a tool call:<\/p>\n<pre><code class=\"language-ts\">\/\/ server\/src\/ticketing\/decide.ts\n[...]\nimport {\n  extractParameters,\n  toParameters,\n  type Extraction,\n  type ToolParameters,\n} from &quot;.\/parameters.ts&quot;;\nimport { selectTool, type ToolSelection } from &quot;.\/selection.ts&quot;;\nimport type { State } from &quot;.\/state.ts&quot;;\n\n[...]\n\nexport async function decide(state: State): Promise&lt;Decision&gt; {\n  const started = performance.now();\n  const result = await Promise.all([\n    selectTool(state),\n    extractParameters(state),\n  ]);\n  const durationMs = performance.now() - started;\n  const [selection, extraction] = result;\n\n  const action = toAction(selection, extraction);\n  [...]\n}<\/code><\/pre>\n<p>The function <code>selectTool<\/code> asks Clef, and <code>extractParameters<\/code> asks Clairic. When <code>toAction<\/code> builds the parameters, it only accepts a departure, destination, or date from Clairic when Clef confirms that the conversation names it. If a flight search lacks the departure or the destination, the assistant asks the user for it instead of calling the tool.<\/p>\n<p><div style=\"\nmargin: 8px 0;\npadding: 22px;\nborder: 1px solid #e5e7eb;\nborder-radius: 14px;\nbackground: #f8fafc;\n\"><\/p>\n<h3 style=\"margin-top:0\">Agentic UI with Angular<\/h3>\n<p>If you don\u2019t just want to connect an agent but embed Agentic UI into a scalable architecture:<br \/>\nIn my book Agentic UI with Angular, I cover the underlying patterns and trade-offs in depth.<\/p>\n<p><a href=\"https:\/\/agentic-angular.com\/\"><img decoding=\"async\" src=\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/04\/cover.png\" width=\"400\" alt=\"Cover of the eBook Agentic UI with Angular\" style=\"cursor:pointer !important\"><\/a><\/p>\n<p><a style=\"cursor:pointer !important\" href=\"https:\/\/agentic-angular.com\/\">More about the eBook \u2192<\/a>\n<\/div>\n<\/p>\n<h2>The Result<\/h2>\n<p>For the return flight request in the state above, Clef returned the following answers:<\/p>\n<pre><code class=\"language-json\">{\n  &quot;model&quot;: &quot;clef&quot;,\n  &quot;answers&quot;: {\n    &quot;tool&quot;: {\n      &quot;type&quot;: &quot;choice&quot;,\n      &quot;choice&quot;: &quot;findFlights&quot;,\n      &quot;probabilities&quot;: {\n        &quot;findFlights&quot;: 0.9918,\n        &quot;findBookings&quot;: 0.0051,\n        &quot;none&quot;: 0.0031\n      },\n      &quot;confidence&quot;: 0.9755\n    },\n    &quot;namesFrom&quot;: { &quot;type&quot;: &quot;noul&quot;, &quot;noul&quot;: 0.8561 },\n    &quot;namesTo&quot;: { &quot;type&quot;: &quot;noul&quot;, &quot;noul&quot;: 0.9297 },\n    &quot;namesDate&quot;: { &quot;type&quot;: &quot;noul&quot;, &quot;noul&quot;: 0.9204 }\n  },\n  &quot;usage&quot;: {\n    &quot;input_tokens&quot;: 1135,\n    &quot;output_tokens&quot;: 0\n  }\n}<\/code><\/pre>\n<p>Clef selects <code>findFlights<\/code> with a probability of 0.99. The three yes\/no answers lie between 0.86 and 0.93 and therefore above the threshold of 0.5. The server takes the departure, the destination, and the date from Clairic. For the same request, Clairic returned the following result. For readability, I rounded its probabilities:<\/p>\n<pre><code class=\"language-json\">{\n  &quot;model&quot;: &quot;clairic&quot;,\n  &quot;answers&quot;: {\n    &quot;from&quot;: {\n      &quot;type&quot;: &quot;text&quot;,\n      &quot;p_null&quot;: 0.008,\n      &quot;span&quot;: [215, 222],\n      &quot;guess&quot;: &quot;Hamburg&quot;,\n      &quot;confidence&quot;: 0.99,\n      &quot;value&quot;: &quot;Hamburg&quot;\n    },\n    &quot;to&quot;: {\n      &quot;type&quot;: &quot;text&quot;,\n      &quot;p_null&quot;: 0.004,\n      &quot;span&quot;: [207, 211],\n      &quot;guess&quot;: &quot;Graz&quot;,\n      &quot;confidence&quot;: 0.98,\n      &quot;value&quot;: &quot;Graz&quot;\n    },\n    &quot;date&quot;: {\n      &quot;type&quot;: &quot;date&quot;,\n      &quot;p_null&quot;: 0.0002,\n      &quot;guess&quot;: &quot;2026-11-04&quot;,\n      &quot;confidence&quot;: 0.98,\n      &quot;value&quot;: &quot;2026-11-04&quot;\n    },\n    &quot;limit&quot;: {\n      &quot;type&quot;: &quot;number&quot;,\n      &quot;p_null&quot;: 0.9999,\n      &quot;guess&quot;: 10,\n      &quot;confidence&quot;: 0.36,\n      &quot;value&quot;: null\n    }\n  },\n  &quot;truncated&quot;: false,\n  &quot;usage&quot;: {\n    &quot;state_tokens&quot;: 92,\n    &quot;image_tokens&quot;: 0,\n    &quot;schema_tokens&quot;: 811,\n    &quot;input_tokens&quot;: 1087,\n    &quot;output_tokens&quot;: 0,\n    &quot;passes&quot;: 3\n  }\n}<\/code><\/pre>\n<p>The object <code>answers<\/code> contains one entry per field. Each entry provides these properties:<\/p>\n<ul>\n<li><code>value<\/code> is the extracted value. It is <code>null<\/code> when the input does not determine the field.<\/li>\n<li><code>guess<\/code> is Clairic's best guess, even when <code>value<\/code> is <code>null<\/code>.<\/li>\n<li><code>p_null<\/code> is the probability that the input does not contain the value.<\/li>\n<li><code>confidence<\/code> indicates how sure Clairic is about its answer.<\/li>\n<li><code>span<\/code> holds the start and end offsets of the value within the state. Only text fields have it.<\/li>\n<\/ul>\n<p>Clairic recognizes the return flight and swaps the cities of the outbound flight. Hamburg becomes the departure and Graz the destination. Both spans point to the traveller's first message, which asks for the connections <em>from Graz to Hamburg<\/em>. As a date field, <code>date<\/code> has no span. Clairic computed its value from <em>in 10 days<\/em> and today's date.<\/p>\n<p>The field <code>limit<\/code> is the most interesting one. The message contains the number 10, so Clairic's <code>guess<\/code> is 10. However, <code>p_null<\/code> is close to 1, as the 10 refers to days and not to the number of flights. Consequently, <code>value<\/code> is <code>null<\/code>.<\/p>\n<p>As with Clef, the probabilities help with the control flow. Below a threshold, the application can ask the user to confirm a value. The right threshold depends on the use case, and tests with real inputs help to find it. The <code>usage<\/code> sections show that neither model generates output tokens. Most of Clairic's 1,087 input tokens come from the field descriptions: 811 schema tokens versus 92 tokens for the state.<\/p>\n<h2>Deriving Values<\/h2>\n<p>Deriving values is one of Clairic's strengths. The second screenshot shows an example:<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/02.png\" alt=\"Chat view: the user writes &quot;Show flights to London, from Graz. In 10 days&quot;. The assistant calls findFlights and shows two flights from Graz to London on Wednesday, November 4, 2026. Clef took 614 ms, Clairic 615 ms, and running both models in parallel 617 ms.\" \/><\/p>\n<p>The message <em>Show flights to London, from Graz. In 10 days<\/em> contains no date. Clairic computes it from the current date in the state. On October 25, 2026, <em>in 10 days<\/em> results in November 4. The flight API cannot filter by date. Hence, the server filters the flights for this day in memory.<\/p>\n<p>This ability ends at text fields. A text answer is always a span of the input and therefore a verbatim copy. Clairic cannot use its world knowledge to turn an airport code such as HAM into Hamburg, even if the instructions ask for it. Jev managed this in my previous article, because Hamburg was one of its options. In this specific case, a deterministic solution is the better choice anyway. The function <code>normalizeCity<\/code> maps aliases such as Vienna to the city names of the flight API. A table of airport codes would work the same way.<\/p>\n<h2>Performance and Trade-offs<\/h2>\n<p>In most of my test runs, both models answered in under a second, including the network. Workers AI does not report how long the model itself needed. As the server calls both models in parallel, the slower of the two determines the total time. However, some tool calls get by with Clef alone, for instance when a tool has no parameters or when its parameters come from a fixed set of values, such as the airports in my <a href=\"https:\/\/www.angulararchitects.io\/en\/blog\/using-jev-for-agentic-ui-just-a-trend-or-a-game-changer\/\">article on Jev<\/a>. This offers further potential for optimization.<\/p>\n<p>At the time of writing in October 2026, Cloudflare only charges for input tokens: $0.24 per million for Clef and $0.10 per million for Clairic. TypeSafe charges even less for Jev: $0.042 per million input tokens. In my test setup, Jev combined with Clairic delivered results comparable to those of Clef. For extraction models such as Clairic, no independent benchmark comparable to the Decision Index exists yet. Nevertheless, these results are very promising, especially for Agentic UIs, which have to react to user input quickly.<\/p>\n<p>This speed comes with a trade-off. An agent framework lets an LLM pick a tool and fill in its arguments based on the tool descriptions. For Clef and Clairic, I had to program every use case myself: the questions for Clef, the fields for Clairic, and the code that combines both results into a tool call. No comfortable agent framework took this work off my hands. The implementation is therefore more complex and leaves more room for errors.<\/p>\n<style>\ntable {\n  width: 100%;\n  margin: 12px 0 36px;\n  border-collapse: collapse;\n  font-variant-numeric: tabular-nums;\n}\nth, td {\n  padding: 9px 12px;\n  text-align: left;\n  vertical-align: top;\n  border-bottom: 1px solid #e5e7eb;\n}\ntd:first-child {\n  font-weight: 600;\n  white-space: nowrap;\n}\nth {\n  font-weight: 600;\n  background: #f8fafc;\n  border-bottom: 2px solid #cbd5e1;\n}\ntr:last-child td {\n  border-bottom: 2px solid #cbd5e1;\n}\n@media (max-width: 600px) {\n  table {\n    font-size: 12.5px;\n  }\n  th, td {\n    padding: 7px 5px;\n  }\n  td:first-child {\n    white-space: normal;\n  }\n}\n<\/style>\n<h2>Local Hosting with Open-Weight Models<\/h2>\n<p>System One models do not write text token by token. Instead, they read the input in one or a few parallel passes. How much hardware a model needs still depends on its size, but narrow tasks such as tool selection open the door to smaller models. This makes System One models good candidates for local hosting on your own servers, on edge devices, or in the browser. Local inference removes the network share of the round trip and keeps sensitive data on your premises. How fast the model itself answers then depends on the local hardware.<\/p>\n<p>Clef already allows this step. Cloudflare publishes its weights on <a href=\"https:\/\/huggingface.co\/Cloudflare\/clef\">Hugging Face<\/a>. The model card names Transformers, vLLM, and SGLang for self-hosting. Quantized variants on Hugging Face also run on llama.cpp, Ollama, and LM Studio. SGLang and Ollama, from version 0.35, provide an endpoint for System One requests. In the example, only the function <code>evaluate<\/code> knows where Clef runs. Switching to a local server therefore only affects this function. Clef-flash with its 9B parameters places lower demands on the hardware than Clef with 27B.<\/p>\n<p>Clairic is cloud-only for now. Cloudflare intends to release its weights after further development. Until then, the extraction part of the example stays on Workers AI, and the conversation still leaves your premises.<\/p>\n<p>Besides Clef, there are further decision models for classification tasks such as tool selection:<\/p>\n<table>\n<thead>\n<tr>\n<th>Model<\/th>\n<th>Runs locally<\/th>\n<th>Characteristics<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><a href=\"https:\/\/huggingface.co\/Cloudflare\/clef\">Clef and Clef-flash<\/a><\/td>\n<td>Yes<\/td>\n<td>Cloudflare. 27B and 9B parameters on Qwen. Apache 2.0. Same API as Jev. Reads images. Hosted on Workers AI as well.<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/docs.typesafe.ai\">Jev<\/a><\/td>\n<td>No<\/td>\n<td>TypeSafe's hosted API. First System One model. Choice, yes\/no, and score questions.<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/jaredpalmer\/kev\">Kev<\/a><\/td>\n<td>Yes<\/td>\n<td>Four sizes from 0.8B to 27B on Qwen. Apache 2.0. Same API as Jev. Runs on Apple Silicon via MLX.<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/NandhaKishorM\/laya\">Laya<\/a><\/td>\n<td>Yes<\/td>\n<td>Encoder models with 322M to 421M parameters. Apache 2.0. Multilingual variant for over 100 languages. Jev-compatible server. Runs on CPU and via ONNX Runtime in Node.js and the browser.<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/www.liquid.ai\/blog\/d1-open\">Liquid AI d1<\/a><\/td>\n<td>Yes<\/td>\n<td>3B and 600M parameters. Built for edge devices. Supports llama.cpp.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>For extracting parameters, the following models are available:<\/p>\n<table>\n<thead>\n<tr>\n<th>Model<\/th>\n<th>Runs locally<\/th>\n<th>Characteristics<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><a href=\"https:\/\/developers.cloudflare.com\/workers-ai\/models\/clairic\/\">Clairic<\/a><\/td>\n<td>Not yet<\/td>\n<td>Cloudflare. First System One extraction model. Typed fields, derived values, estimates, and forecasts. Open weights announced.<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/fastino-ai\/GLiNER2\">GLiNER2<\/a><\/td>\n<td>Yes<\/td>\n<td>Fastino. 74M to 340M parameters. Apache 2.0. Runs on CPU. Returns spans for entities and structured records. Computes no values.<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/huggingface.co\/numind\/NuExtract-2.0-8B\">NuExtract 2.0<\/a><\/td>\n<td>Yes<\/td>\n<td>NuMind. 2B to 8B parameters on Qwen-VL. Generative model that fills a JSON template from text and images. MIT for 2B and 8B.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>None of the open alternatives works like Clairic yet. GLiNER2 also returns spans but computes no values. NuExtract generates JSON and therefore behaves more like a small LLM. The community project <a href=\"https:\/\/github.com\/hiemanshu\/clarke-flash\">Clarke<\/a> follows Clairic's approach. At the time of writing, it only provides training code and no published weights.<\/p>\n<p>Laya and GLiNER2 show how small such models can be. With fewer than half a billion parameters, these small language models run on an ordinary CPU.<\/p>\n<h2>Conclusion<\/h2>\n<p>Clef and Clairic complement each other. Clef decides which tool to call, and Clairic extracts its parameters, including values it derives, such as dates. Both run on Workers AI and share one set of keys. Running in parallel, they delivered typed results in under a second in most of my test runs. The price is more code: without an agent framework, each use case needs its own implementation.<\/p>\n<p>The road to local hosting is half done. Clef's weights are available today, and a local server only changes where the request goes. Once Cloudflare releases Clairic's weights, the whole example can run on your own hardware.<\/p>\n<hr \/>\n<p><div style=\"\nmargin: 8px 0;\npadding: 22px;\nborder: 1px solid #e5e7eb;\nborder-radius: 14px;\nbackground: #f8fafc;\n\"><\/p>\n<h3 style=\"margin-top:0\">Interested in production-ready Agentic UI architectures?<\/h3>\n<p>In my workshop, we dive into AG-UI, A2UI, MCP Apps, HITL patterns, and modern Angular architectures for real-world agentic systems.<\/p>\n<p><a href=\"https:\/\/www.angulararchitects.io\/en\/training\/agentic-ai-with-angular-architecture-patterns\/\"><img decoding=\"async\" src=\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/05\/sujet-workshop-en.png\" width=\"400\" alt=\"Workshop: Agentic AI with Angular \u2013 AG-UI, A2UI, MCP Apps & HITL patterns\" style=\"cursor:pointer !important\"><\/a><\/p>\n<p><a style=\"cursor:pointer !important\" href=\"https:\/\/www.angulararchitects.io\/en\/training\/agentic-ai-with-angular-architecture-patterns\/\">See all details \u2192<\/a>\n<\/div>\n<\/p>\n<h2>FAQ<\/h2>\n<h3>What are System One models?<\/h3>\n<p>System One models answer typed questions about an input instead of generating text. Decision models such as Jev and Clef choose among predefined options and return probabilities. Extraction models such as Clairic return typed values like text spans, numbers, and dates.<\/p>\n<h3>How does Clef relate to Jev?<\/h3>\n<p>Clef follows the System One API that TypeSafe introduced with Jev. An existing Jev integration switches to Clef by changing the endpoint and the model. Unlike Jev, Clef comes with open weights under the Apache 2.0 license.<\/p>\n<h3>How do Clef and Clairic differ?<\/h3>\n<p>Clef selects among options you define up front. This suits decisions such as tool selection. Clairic extracts values you cannot list in advance, such as names and dates, and derives values such as the date behind <em>in 10 days<\/em>.<\/p>\n<h3>Can Clef and Clairic run locally?<\/h3>\n<p>Clef can. Its weights are available on Hugging Face, and servers such as vLLM, SGLang, and Ollama run it. Clairic is a cloud service on Workers AI for now, but Cloudflare intends to release its weights.<\/p>\n<h3>Does Clairic normalize text values?<\/h3>\n<p>No. Text answers are spans of the input, so an airport code such as HAM stays HAM. A deterministic lookup table handles such mappings.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>This is post 2 of 2 in the series &ldquo;Compact and System One Models&rdquo; Using Jev for Agentic UI: Just a Trend or a Game Changer? Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting Clef selects the tool, Clairic extracts the parameters, and open weights bring the decision part to [&hellip;]<\/p>\n","protected":false},"author":25,"featured_media":35177,"comment_status":"open","ping_status":"open","sticky":true,"template":"","format":"standard","meta":{"_acf_changed":false,"_price":"","_stock":"","_tribe_ticket_header":"","_tribe_default_ticket_provider":"","_ticket_start_date":"","_ticket_end_date":"","_tribe_ticket_show_description":"","_tribe_ticket_show_not_going":false,"_tribe_ticket_use_global_stock":"","_tribe_ticket_global_stock_level":"","_global_stock_mode":"","_global_stock_cap":"","_tribe_rsvp_for_event":"","_tribe_ticket_going_count":"","_tribe_ticket_not_going_count":"","_tribe_tickets_list":"[]","_tribe_ticket_has_attendee_info_fields":false,"footnotes":""},"categories":[18],"tags":[],"class_list":["post-35181","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized","post_series-compact-and-system-one-models"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.1.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting - ANGULARarchitects<\/title>\n<meta name=\"description\" content=\"Cloudflare&#039;s open-weight decision model Clef selects the tool, the System One extraction model Clairic extracts the parameters, and both run in parallel. Plus: how far the road to local, self-hosted Agentic UI already reaches.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting - ANGULARarchitects\" \/>\n<meta property=\"og:description\" content=\"Cloudflare&#039;s open-weight decision model Clef selects the tool, the System One extraction model Clairic extracts the parameters, and both run in parallel. Plus: how far the road to local, self-hosted Agentic UI already reaches.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\" \/>\n<meta property=\"og:site_name\" content=\"ANGULARarchitects\" \/>\n<meta property=\"article:published_time\" content=\"2026-10-25T20:47:19+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-10-26T09:38:09+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/social-sujet-1024x538.png\" \/>\n<meta name=\"author\" content=\"Manfred Steyer\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:image\" content=\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/social-sujet-1024x538.png\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Manfred Steyer\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"18 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\"},\"author\":{\"name\":\"Manfred Steyer\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#\/schema\/person\/f3de69c1e2bdb5ba04d8d2f5f998b81a\"},\"headline\":\"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting\",\"datePublished\":\"2026-10-25T20:47:19+00:00\",\"dateModified\":\"2026-10-26T09:38:09+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\"},\"wordCount\":2909,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#organization\"},\"image\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\",\"url\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\",\"name\":\"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting - ANGULARarchitects\",\"isPartOf\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png\",\"datePublished\":\"2026-10-25T20:47:19+00:00\",\"dateModified\":\"2026-10-26T09:38:09+00:00\",\"description\":\"Cloudflare's open-weight decision model Clef selects the tool, the System One extraction model Clairic extracts the parameters, and both run in parallel. Plus: how far the road to local, self-hosted Agentic UI already reaches.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage\",\"url\":\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png\",\"contentUrl\":\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png\",\"width\":1920,\"height\":1080},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.angulararchitects.io\/en\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#website\",\"url\":\"https:\/\/www.angulararchitects.io\/en\/\",\"name\":\"ANGULARarchitects\",\"description\":\"AngularArchitects.io\",\"publisher\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.angulararchitects.io\/en\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#organization\",\"name\":\"ANGULARarchitects\",\"alternateName\":\"SOFTWAREarchitects\",\"url\":\"https:\/\/www.angulararchitects.io\/en\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2023\/07\/AA-Logo-RGB-horizontal-inside-knowledge-black.svg\",\"contentUrl\":\"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2023\/07\/AA-Logo-RGB-horizontal-inside-knowledge-black.svg\",\"width\":644,\"height\":216,\"caption\":\"ANGULARarchitects\"},\"image\":{\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/github.com\/angular-architects\",\"https:\/\/www.linkedin.com\/company\/angular-architects\/\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#\/schema\/person\/f3de69c1e2bdb5ba04d8d2f5f998b81a\",\"name\":\"Manfred Steyer\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.angulararchitects.io\/en\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/8778dfb353992fa3a0d909beee085a088891e5bfce65cdb3631801da527cf11b?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/8778dfb353992fa3a0d909beee085a088891e5bfce65cdb3631801da527cf11b?s=96&d=mm&r=g\",\"caption\":\"Manfred Steyer\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting - ANGULARarchitects","description":"Cloudflare's open-weight decision model Clef selects the tool, the System One extraction model Clairic extracts the parameters, and both run in parallel. Plus: how far the road to local, self-hosted Agentic UI already reaches.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/","og_locale":"en_US","og_type":"article","og_title":"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting - ANGULARarchitects","og_description":"Cloudflare's open-weight decision model Clef selects the tool, the System One extraction model Clairic extracts the parameters, and both run in parallel. Plus: how far the road to local, self-hosted Agentic UI already reaches.","og_url":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/","og_site_name":"ANGULARarchitects","article_published_time":"2026-10-25T20:47:19+00:00","article_modified_time":"2026-10-26T09:38:09+00:00","og_image":[{"url":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/social-sujet-1024x538.png","type":"","width":"","height":""}],"author":"Manfred Steyer","twitter_card":"summary_large_image","twitter_image":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/social-sujet-1024x538.png","twitter_misc":{"Written by":"Manfred Steyer","Est. reading time":"18 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#article","isPartOf":{"@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/"},"author":{"name":"Manfred Steyer","@id":"https:\/\/www.angulararchitects.io\/en\/#\/schema\/person\/f3de69c1e2bdb5ba04d8d2f5f998b81a"},"headline":"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting","datePublished":"2026-10-25T20:47:19+00:00","dateModified":"2026-10-26T09:38:09+00:00","mainEntityOfPage":{"@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/"},"wordCount":2909,"commentCount":0,"publisher":{"@id":"https:\/\/www.angulararchitects.io\/en\/#organization"},"image":{"@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage"},"thumbnailUrl":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png","inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/","url":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/","name":"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting - ANGULARarchitects","isPartOf":{"@id":"https:\/\/www.angulararchitects.io\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage"},"image":{"@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage"},"thumbnailUrl":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png","datePublished":"2026-10-25T20:47:19+00:00","dateModified":"2026-10-26T09:38:09+00:00","description":"Cloudflare's open-weight decision model Clef selects the tool, the System One extraction model Clairic extracts the parameters, and both run in parallel. Plus: how far the road to local, self-hosted Agentic UI already reaches.","breadcrumb":{"@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#primaryimage","url":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png","contentUrl":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2026\/10\/hero.png","width":1920,"height":1080},{"@type":"BreadcrumbList","@id":"https:\/\/www.angulararchitects.io\/en\/blog\/clef-clairic-and-copilotkit-a-promising-trio-and-the-road-to-local-hosting\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.angulararchitects.io\/en\/"},{"@type":"ListItem","position":2,"name":"Clef, Clairic, and CopilotKit: A Promising Trio and the Road to Local Hosting"}]},{"@type":"WebSite","@id":"https:\/\/www.angulararchitects.io\/en\/#website","url":"https:\/\/www.angulararchitects.io\/en\/","name":"ANGULARarchitects","description":"AngularArchitects.io","publisher":{"@id":"https:\/\/www.angulararchitects.io\/en\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.angulararchitects.io\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.angulararchitects.io\/en\/#organization","name":"ANGULARarchitects","alternateName":"SOFTWAREarchitects","url":"https:\/\/www.angulararchitects.io\/en\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.angulararchitects.io\/en\/#\/schema\/logo\/image\/","url":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2023\/07\/AA-Logo-RGB-horizontal-inside-knowledge-black.svg","contentUrl":"https:\/\/www.angulararchitects.io\/wp-content\/uploads\/2023\/07\/AA-Logo-RGB-horizontal-inside-knowledge-black.svg","width":644,"height":216,"caption":"ANGULARarchitects"},"image":{"@id":"https:\/\/www.angulararchitects.io\/en\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/github.com\/angular-architects","https:\/\/www.linkedin.com\/company\/angular-architects\/"]},{"@type":"Person","@id":"https:\/\/www.angulararchitects.io\/en\/#\/schema\/person\/f3de69c1e2bdb5ba04d8d2f5f998b81a","name":"Manfred Steyer","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.angulararchitects.io\/en\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/8778dfb353992fa3a0d909beee085a088891e5bfce65cdb3631801da527cf11b?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/8778dfb353992fa3a0d909beee085a088891e5bfce65cdb3631801da527cf11b?s=96&d=mm&r=g","caption":"Manfred Steyer"}}]}},"_links":{"self":[{"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/posts\/35181","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/users\/25"}],"replies":[{"embeddable":true,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/comments?post=35181"}],"version-history":[{"count":3,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/posts\/35181\/revisions"}],"predecessor-version":[{"id":35189,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/posts\/35181\/revisions\/35189"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/media\/35177"}],"wp:attachment":[{"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/media?parent=35181"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/categories?post=35181"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.angulararchitects.io\/en\/wp-json\/wp\/v2\/tags?post=35181"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}