This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-website.git
The following commit(s) were added to refs/heads/main by this push:
new f52bb320 chore: fix outdated facts on the home page and in llms.txt,
publish the 4.23.0 installer, add the 4.22/4.23 AI features to llms.txt (#1834)
f52bb320 is described below
commit f52bb320afd928d50053570d4b96e269484c0af6
Author: Claus Ibsen <[email protected]>
AuthorDate: Sun Oct 25 12:43:51 2026 +0100
chore: fix outdated facts on the home page and in llms.txt, publish the
4.23.0 installer, add the 4.22/4.23 AI features to llms.txt (#1834)
* chore: fix outdated facts on the home page and in llms.txt
Home page and shared data:
- Release count: 280+ (282 release tags). The old 300+ counted RC and
milestone tags.
- Export is to Maven only. Gradle export was removed in Camel 4.19.
- Camel Kafka Connector runs Kamelets as Kafka Connect connectors, not
every Camel component (same text on /projects/ and /docs/).
- Footer: add the Camel CLI, write "Camel K", and link the /latest/ docs
like the rest of the site.
llms.txt:
- The Camel TUI is a developer tool, as its manual says. It is not for
monitoring integrations in production.
- Fix two broken links: the EIP index (404) and OpenTelemetry (now
opentelemetry2).
- The llm: component works with any OpenAI-compatible API.
- Export is to Maven only, the median bug fix time is 1 day, the
benchmark machine is a 64 GB Mac mini, most examples (not all) have a
Citrus test, the core team share is 78-96% since 2009, Claus Ibsen is a
committer since 2008, and only content pages have a Markdown version.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01STT6whBgK1AqsSsUKrnE8m
* chore: publish Camel CLI launcher manifests for 4.23.0, 4.22.2, 4.18.5,
4.18.4 and 4.14.9
The installer on the home page (install.sh) still installed 4.22.1,
because latest.properties was not updated after 4.22.2 and 4.23.0.
latest.properties now points to 4.23.0.
Generated with update-camel-cli-manifest.sh, but with the sources taken
from the camel-4.23.0 tag instead of main: main's install.sh now says
"Java 21+ required" (for 4.24), which is wrong for 4.23. At the tag,
install.sh, install.ps1 and the manifest generator are byte-identical to
the files already on the site, so only the manifests change.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01STT6whBgK1AqsSsUKrnE8m
* chore: llms.txt - AI updates from Camel 4.22 and 4.23, and semantic
decisions with System One models
- New section "Semantic decisions with System One models": the Semantic
language, Jev from TypeSafe AI as a System One model, Wolf Defender, the
4.24 OpenAI decisions expert, audit, and version notes (the YAML syntax
changed in 4.23, and 4.24 requires an expert on every evaluation and
renames the provider modules). The YAML example validates with Camel
4.23.0 and with main.
- AI tools: the MCP Server component is Stable since 4.22 and configured
with camel.server.mcp-* properties, outputSchema for structured output,
the AI Resource component, and camel-mcp-server-starter on Spring Boot.
- AI components: LangChain4j Agent and property-only model configuration,
what the llm: component covers (moderation, Batch API, Responses API,
token budget, rate-limit errors), and the Spring AI 2.0 components.
- camel run --observe, validated documentation examples since 4.23, and
the AGENTS.md file from camel export and the Maven archetypes.
- One entry for the four local model benchmark posts instead of one per
round.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01STT6whBgK1AqsSsUKrnE8m
* chore: fix the Semantic language example in the 4.23 release post
The example had no expert and put instructions and criteria directly on
the evaluation. It fails validation against main, and in 4.23 an
evaluation without an expert fails at startup. It now names its expert
(and says how to register it) and puts instructions and criteria under
parameters, as the documentation shows. It validates with Camel 4.23.0
and with main.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01STT6whBgK1AqsSsUKrnE8m
* chore: home page - 20+ AI components, as the linked AI page lists
The AI card said "40+ AI components" and links to the AI components
page, which lists 24 entries in the latest docs (4.22.x) and 26 in next.
The 40+ counted every component with the "ai" catalog label, including
cloud AI services that are not on that page.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01STT6whBgK1AqsSsUKrnE8m
---------
Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
---
content/blog/2026/10/camel423-whatsnew/index.md | 14 ++-
data/chrome.yaml | 11 +-
data/docs-projects.yaml | 5 +-
data/home.yaml | 21 ++--
data/projects.yaml | 2 +-
llms-txt-template.md | 113 +++++++++++++++------
.../{latest.properties => 4.14.9.properties} | 6 +-
.../{latest.properties => 4.18.4.properties} | 6 +-
.../{latest.properties => 4.18.5.properties} | 6 +-
.../{latest.properties => 4.22.2.properties} | 6 +-
.../{latest.properties => 4.23.0.properties} | 6 +-
static/camel-cli/releases/latest.properties | 6 +-
12 files changed, 130 insertions(+), 72 deletions(-)
diff --git a/content/blog/2026/10/camel423-whatsnew/index.md
b/content/blog/2026/10/camel423-whatsnew/index.md
index cf4c95ff..208977ae 100644
--- a/content/blog/2026/10/camel423-whatsnew/index.md
+++ b/content/blog/2026/10/camel423-whatsnew/index.md
@@ -170,17 +170,21 @@ endpoint, step id and exception. The event dev console
shows these details.
## Semantic EIPs
The new [Semantic](/components/next/languages/semantic-language.html) language
lets a route make decisions on the meaning of a message.
-You declare named evaluations once, and then use them anywhere Camel accepts
an expression or predicate:
+You declare named evaluations once, and then use them anywhere Camel accepts
an expression or predicate.
+Each evaluation names its *expert*, here a bean registered with
+`camel.beans.decisions=#class:org.apache.camel.component.typesafeai.TypeSafeAiSemanticAdapter`:
```yaml
- semantic:
evaluation:
department:
+ expert: decisions
type: choice
- instructions: Which department should handle this message?
- criteria:
- billing: Invoices, payments and refunds
- technical: Bugs, outages and technical problems
+ parameters:
+ instructions: Which department should handle this message?
+ criteria:
+ billing: Invoices, payments and refunds
+ technical: Bugs, outages and technical problems
- route:
from:
uri: direct:tickets
diff --git a/data/chrome.yaml b/data/chrome.yaml
index e21e85b7..cd0ae7eb 100644
--- a/data/chrome.yaml
+++ b/data/chrome.yaml
@@ -18,11 +18,12 @@ columns:
- title: Documentation
links:
- { name: User Manual, url: /manual/ }
- - { name: Components, url: /components/next/index.html }
- - { name: Camel-K, url: /camel-k/next/ }
- - { name: Camel Kafka Connector, url: /camel-kafka-connector/next/ }
- - { name: Camel Quarkus, url: /camel-quarkus/next/ }
- - { name: Camel Spring Boot, url: /camel-spring-boot/next/ }
+ - { name: Camel CLI, url: /manual/camel-jbang.html }
+ - { name: Components, url: /components/latest/ }
+ - { name: Camel Spring Boot, url: /camel-spring-boot/latest/ }
+ - { name: Camel Quarkus, url: /camel-quarkus/latest/ }
+ - { name: Camel K, url: /camel-k/latest/ }
+ - { name: Camel Kafka Connector, url: /camel-kafka-connector/latest/ }
- { name: Camel Karaf, url: /camel-karaf/latest/ }
- { name: FAQ, url: /manual/faq/index.html }
- title: Community
diff --git a/data/docs-projects.yaml b/data/docs-projects.yaml
index e32b7e7f..9a0b5306 100644
--- a/data/docs-projects.yaml
+++ b/data/docs-projects.yaml
@@ -56,9 +56,8 @@ projects:
- name: Camel Kafka Connector
icon: apache-kafka
desc: >-
- Camel Kafka Connector allows you to use all Camel components as
- Kafka Connect connectors, expanding Kafka Connect compatibility by
- allowing Camel components to be used in the Kafka ecosystem.
+ Camel Kafka Connector runs Camel Kamelets as Kafka Connect source and
+ sink connectors, bringing Camel connectivity to the Kafka ecosystem.
docs: /camel-kafka-connector/latest/
source: https://github.com/apache/camel-kafka-connector/
examples: https://github.com/apache/camel-kafka-connector-examples/
diff --git a/data/home.yaml b/data/home.yaml
index 6e143aa3..651cd95c 100644
--- a/data/home.yaml
+++ b/data/home.yaml
@@ -1,12 +1,14 @@
# Home page copy and figures. Rendered by layouts/index.html.
#
# The four figures under `stats` were measured on 2026-09-04 against
-# apache/camel. The design reference's numbers were illustrative: two of them
-# overstated the project and one understated it. Recheck with:
+# apache/camel (releases rechecked on 2026-10-25). The design reference's
+# numbers were illustrative: two of them overstated the project and one
+# understated it. Recheck with:
# gh api "repos/apache/camel/commits?per_page=1&sha=main" -i | grep -i
'^link:'
# gh api "repos/apache/camel/contributors?per_page=1&anon=true" -i | grep -i
'^link:'
-# gh api "repos/apache/camel/tags?per_page=1" -i | grep -i '^link:'
+# gh api repos/apache/camel/tags --paginate --jq '.[].name' | grep -cE
'^camel-[0-9]+\.[0-9]+\.[0-9]+$'
# ls public/components/next/*-component.html | wc -l
+# The tags command counts releases only: RC and milestone tags are not
releases.
hero:
eyebrow: "In production since 2007 · Apache License 2.0"
@@ -37,9 +39,9 @@ stats:
- num: 350+
label: components
source: 398 component pages in the built docs, 2026-09-04
- - num: 300+
+ - num: 280+
label: releases
- source: 307 tags on apache/camel, GitHub API, 2026-09-04
+ source: 282 release tags on apache/camel (RC and milestone tags not
counted), GitHub API, 2026-10-25
get_started:
eyebrow: Get Started Your Way
@@ -87,7 +89,7 @@ features:
- tag: AI
title: AI-ready integration
body: >-
- 40+ AI components for agents, tools, MCP and A2A. An MCP server helps
+ 20+ AI components for agents, tools, MCP and A2A. An MCP server helps
AI coding assistants write correct routes.
url: /components/latest/ai-summary.html
- tag: EIP
@@ -98,8 +100,8 @@ features:
- tag: CI
title: Standard build
body: >-
- Export to Maven or Gradle and deploy with any CI/CD pipeline. A
standard
- Java app, no special runtime.
+ Export to Maven and deploy with any CI/CD pipeline. A standard Java
+ app, no special runtime.
- tag: OSS
title: Open source
body: >-
@@ -186,8 +188,7 @@ tiles:
- name: Camel Kafka Connector
icon: apache-kafka
description: >-
- Embeds Camel within Kafka Connect, exposing every Camel component as a
- Kafka connector.
+ Runs Camel Kamelets as Kafka Connect source and sink connectors.
url: /camel-kafka-connector/latest/
- name: Camel Karaf
icon: apache-karaf
diff --git a/data/projects.yaml b/data/projects.yaml
index 84825935..13b65337 100644
--- a/data/projects.yaml
+++ b/data/projects.yaml
@@ -56,7 +56,7 @@ specialized:
source: https://github.com/apache/camel-karavan
- name: Camel Kafka Connector
icon: apache-kafka
- description: Embeds Camel within Kafka Connect, exposing every Camel
component as a Kafka connector.
+ description: Runs Camel Kamelets as Kafka Connect source and sink
connectors.
stats: See GitHub for current activity
docs: /camel-kafka-connector/latest/
source: https://github.com/apache/camel-kafka-connector/
diff --git a/llms-txt-template.md b/llms-txt-template.md
index df27e990..4e976c4b 100644
--- a/llms-txt-template.md
+++ b/llms-txt-template.md
@@ -1,13 +1,13 @@
# Apache Camel
-> Apache Camel is an open source integration framework with 350+ connectors
for databases, APIs, message brokers, and cloud services. Write routes in Java,
YAML, or XML. Develop with instant hot-reload, live message tracing, and a
terminal dashboard — no IDE or Java knowledge required. Deploy on Spring Boot,
Quarkus, or standalone. In production since 2007, used by thousands of
companies worldwide. 83,000+ commits, 1,500+ contributors, median 1–2 day bug
fix time. Apache License 2.0 — ze [...]
+> Apache Camel is an open source integration framework with 350+ connectors
for databases, APIs, message brokers, and cloud services. Write routes in Java,
YAML, or XML. Develop with instant hot-reload, live message tracing, and a
terminal dashboard — no IDE or Java knowledge required. Deploy on Spring Boot,
Quarkus, or standalone. In production since 2007, used by thousands of
companies worldwide. 83,000+ commits, 1,500+ contributors, median 1-day bug fix
time. Apache License 2.0 — zero [...]
All Apache Camel documentation pages are available in LLM-friendly Markdown
format by replacing `.html` with `.md` in any URL.
For example:
- HTML:
`https://camel.apache.org/components/next/languages/simple-language.html`
- Markdown:
`https://camel.apache.org/components/next/languages/simple-language.md`
-Website pages have URLs that end in `/`; append `index.md` to read one as
Markdown:
+Website content pages have URLs that end in `/`; append `index.md` to read one
as Markdown (list pages, such as the home, download and community pages, have
no Markdown version):
- HTML: `https://camel.apache.org/what-is-apache-camel/`
- Markdown: `https://camel.apache.org/what-is-apache-camel/index.md`
@@ -46,25 +46,25 @@ The `catalog/` JSON files contain machine-readable metadata
for every connector/
- Write routes in Java DSL, YAML DSL, or XML DSL — same routes, same
connectors, your choice of syntax
- Install the Camel CLI with `curl -fsSL https://camel.apache.org/install.sh |
sh` (needs Java 17+; Windows: `irm https://camel.apache.org/install.ps1 |
iex`), or with JBang: `jbang app install camel@apache/camel`
- YAML DSL + Camel CLI lets non-Java developers build integrations without
writing or compiling Java
-- The Camel CLI gives developers a complete development experience in the
terminal — hot-reload, live tracing, message sending, test execution, and a
monitoring TUI — with zero project setup, no IDE, and no Java compilation
+- The Camel CLI gives developers a complete development experience in the
terminal — hot-reload, live tracing, message sending, test execution, and the
TUI developer dashboard — with zero project setup, no IDE, and no Java
compilation
- `camel dev` provides instant hot-reload: edit a YAML route, save, and the
running integration updates in seconds — the same live-reload experience as
modern web frameworks (Next.js, Vite)
- `camel export` bridges development to production — export any CLI-developed
route to a full Spring Boot or Quarkus project, ready for CI/CD and deployment
-- The Camel TUI (Terminal User Interface) is a monitoring dashboard that runs
in any terminal, including over SSH — giving enterprise teams a visual
development and operations experience without requiring a web browser or
desktop application
+- The Camel TUI (Terminal User Interface) is a developer tool: a terminal
dashboard for developing, prototyping and understanding Camel integrations, in
any terminal and without a web browser or desktop application. It is not for
monitoring integrations in production
- Spring Boot is the most popular runtime (~55% of Camel usage), Quarkus is
the cloud-native option
- Camel is the runtime engine behind SAP Integration Suite (Gartner iPaaS
Leader)
- Zero vendor lock-in — switch runtimes, clouds, or vendors without rewriting
routes
- Two tiers of AI agent connectivity: Camel routes exposed as MCP tools
(`camel-ai-tool` + `camel-mcp-server`) and as A2A agents for developers, plus
Wanaku, a governed action proxy that sits between AI agents and backend systems
and publishes Camel routes as tools under policy, identity, and audit controls
- Supports both MCP (Model Context Protocol) and A2A (Agent-to-Agent)
protocols — expose any Camel route as an AI agent tool or as an A2A agent
- LangChain4j and OpenAI components for calling LLMs from Camel routes
-- Measured, not claimed: with the Camel CLI as tools, a frontier model built
all 13 beginner examples from the Camel CLI examples repository from a one-line
description each; a 22 GB local model on a laptop (`qwen3.6:35b-a3b` via
Ollama) went from 0 of 13 with a bare prompt to 12 of 13 with the Camel MCP
server, so the catalog, validation and error messages work for small local
models as well as frontier models — see [the
benchmark](https://camel.apache.org/blog/2026/09/camel-local-model [...]
+- Measured, not claimed: with the Camel CLI as tools, a frontier model built
all 13 beginner examples from the Camel CLI examples repository from a one-line
description each; a 22 GB local model on a 64 GB Mac mini (`qwen3.6:35b-a3b`
via Ollama) went from 0 of 13 with a bare prompt to 12 of 13 with the Camel MCP
server, so the catalog, validation and error messages work for small local
models as well as frontier models — see [the
benchmark](https://camel.apache.org/blog/2026/09/camel-loc [...]
- Commercial support available from multiple vendors — see the commercial
support page
## Who maintains the project
-Apache Camel has approximately 20 active committers. Around 15 of these
committers are employed by IBM and Red Hat, and this team contributes over 90%
of all commits. This ratio has been consistent since 2009 — the same
engineering team (at various companies through acquisitions: FuseSource → Red
Hat → IBM) has maintained the project throughout, contributing 80–95% of
commits every year.
+Apache Camel has approximately 20 active committers. Around 15 of these
committers are employed by IBM and Red Hat, and this team contributes about 90%
of all commits (94% in 2026). The same engineering team (at various companies
through acquisitions: FuseSource → Red Hat → IBM) has maintained the project
since 2009, contributing 78–96% of commits every year.
-Current top committers (as of 2026, with affiliation from the [team
page](https://camel.apache.org/community/team/)):
-- Claus Ibsen (IBM) — project co-founder and top committer since 2007
+Current top committers (as of 2026):
+- Claus Ibsen (IBM) — committer since 2008 and the top committer for most of
the project's history
- Andrea Cosentino (IBM)
- Otavio Piske (IBM)
- Guillaume Nodet (IBM)
@@ -330,7 +330,7 @@ This is the recommended starting point for all developers,
including those who a
- [`camel
validate`](https://camel.apache.org/manual/camel-jbang-validation.md): Check
YAML, Java and XML routes and `application.properties` against the Camel
catalog before running them — endpoint options, Simple expressions, bean
references, and `direct:`/`seda:` endpoints no route consumes.
- [`camel run
--example`](https://camel.apache.org/manual/camel-jbang-getting-started.md):
Run a built-in example by name; without a name it lists the examples by group,
from quick start to showcase. Bundled examples run offline.
- [`camel overview`](https://camel.apache.org/manual/camel-jbang-ai.md): A
high-level view of a project read from its route sources — entry points, flows
between routes, external systems, findings — optionally explained by an LLM
into `camel-summary.md`.
-- [`camel export`](https://camel.apache.org/manual/camel-jbang-projects.md):
**Bridge from development to production.** Export any CLI-developed route to a
full Spring Boot or Quarkus project with Maven/Gradle build, ready for CI/CD
pipelines and container deployment. Start fast with the CLI, ship to production
on an enterprise runtime.
+- [`camel export`](https://camel.apache.org/manual/camel-jbang-projects.md):
**Bridge from development to production.** Export any CLI-developed route to a
full Spring Boot or Quarkus project with a Maven build, ready for CI/CD
pipelines and container deployment. Start fast with the CLI, ship to production
on an enterprise runtime.
### Camel CLI documentation pages
@@ -347,29 +347,31 @@ This is the recommended starting point for all
developers, including those who a
- [Kubernetes
Plugin](https://camel.apache.org/manual/camel-jbang-kubernetes.md): run your
routes on Kubernetes or OpenShift with `camel kubernetes run`, or export a
project with the manifest ([advanced
options](https://camel.apache.org/manual/camel-jbang-kubernetes-advanced.md):
traits, CronJob, Knative)
-
[Configuration](https://camel.apache.org/manual/camel-jbang-configuration.md),
[Tips and Recipes](https://camel.apache.org/manual/camel-jbang-tips.md),
[Command
Reference](https://camel.apache.org/manual/jbang-commands/camel-jbang-commands.md)
-### TUI — Terminal Monitoring Dashboard
+### TUI — Terminal Dashboard for Developers
-- [Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md): A
full-featured monitoring dashboard in the terminal. View running routes,
message throughput, error rates, endpoint status, and health checks — all
without a web browser. Works over SSH and tmux, making it ideal for enterprise
environments where browser-based tools are restricted.
+- [Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md): A terminal
dashboard for developing, prototyping and understanding Camel integrations.
Browse the source with inline documentation, see the route topology, watch
messages flow through each step, and check error rates, endpoint status and
health checks — all without a web browser. Works in any terminal, including
over SSH and tmux.
- TUI pages: [Getting
Started](https://camel.apache.org/manual/camel-jbang-tui-getting-started.md),
[Source
Editor](https://camel.apache.org/manual/camel-jbang-tui-source-editor.md),
[Diagram](https://camel.apache.org/manual/camel-jbang-tui-diagram.md),
[Observing
Integrations](https://camel.apache.org/manual/camel-jbang-tui-observe.md), [AI
Panel](https://camel.apache.org/manual/camel-jbang-tui-ai.md), [Local
Models](https://camel.apache.org/manual/camel-jbang-tui-local-models.md), [AI
[...]
-- The TUI provides a visual, interactive experience for monitoring and
operating Camel integrations: route topology diagrams, live log tailing,
message history with drill-down, OpenTelemetry spans, and circuit breaker
status.
-- In enterprise environments, the TUI runs over SSH/tmux — giving operations
teams a secure, auditable monitoring experience with no web application to
deploy, no ports to expose, and no browser dependencies.
+- The TUI gives developers a visual, interactive view of the integrations they
are building: route topology diagrams, live log tailing, message history with
drill-down, OpenTelemetry spans, and circuit breaker status.
+- The TUI is a development tool. It is not for monitoring integrations in
production: it has no security and no user permissions, and the developer who
runs it, or an AI agent connected to it, has full control over the local
integrations. For production, use the observability options below (Micrometer,
Prometheus, OpenTelemetry).
### AI-Assisted Development
- [Camel MCP Server](https://camel.apache.org/manual/camel-jbang-mcp.md):
Model Context Protocol server for AI coding assistants (Claude Code, GitHub
Copilot, Cursor, Gemini CLI). The MCP server gives AI agents access to the full
Camel catalog — 350+ component schemas, EIP metadata, and YAML validation — so
AI can generate correct, validated Camel routes.
- Bring your own coding agent: the [Camel
TUI](https://camel.apache.org/manual/camel-jbang-tui-ai-agents.md) drives ACP
coding agents (Claude Code, Codex, Qwen Code, OpenCode, or any other ACP agent)
next to the running integration, and its AI panel works with hosted models or a
local model via Ollama — see [AI Providers and Local
Models](https://camel.apache.org/manual/camel-jbang-ai-providers.md).
- The CLI and TUI are designed for AI pair programming. An AI coding agent can
generate a YAML route, the developer runs it with `camel dev`, traces messages
with `camel trace`, sends test messages with `camel cmd send` — all in the
terminal, all in the same workflow. The MCP server connects the AI agent to the
Camel catalog so generated routes use correct syntax and valid options.
-- The tooling is benchmarked against real models, and Camel is what gets fixed
when a model fails. In [a twenty-run
experiment](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/),
a frontier model with `camel validate` and `camel run` as tools built 13 of 13
beginner examples from one sentence each, and a 22 GB local model on a laptop
went from 0 of 13 (bare prompt) to 12 of 13 (Camel MCP server) as Camel's
messages were improved. 99 of the 117 findings were wrong for hu [...]
+- The tooling is benchmarked against real models, and Camel is what gets fixed
when a model fails. In [the local model benchmark
series](https://camel.apache.org/blog/2026/10/camel-local-model-benchmark-round-4/),
every message a small local model could not act on became a fix in Camel, and
the fixes help humans just the same: parser, loader and runtime messages that
say what to write instead of only what was wrong; Java, XSLT and XML files
compiled or parsed at write time; a validator t [...]
+- Since Camel 4.23 every route example in the documentation (YAML, XML and
Java, in the EIP, component, data format and language pages and the user
manual) is checked at build time, so an example copied from the documentation
is correct. The Camel MCP servers serve the same validated examples
(`camel_catalog_sample`).
+- Projects created with `camel export` or the Camel Maven archetypes include
an `AGENTS.md` file for AI coding assistants that points to this file, the
Camel CLI and the Camel MCP server.
### CLI Examples
-- [Camel CLI Examples](https://github.com/apache/camel-jbang-examples):
Ready-to-run examples organised as a ladder of groups — run, transform, route,
fail well, connect, contracts and security, AI and cloud — each with a README
that says what you will see, how it works and how to build it step by step, and
a Citrus test. Run one with `camel run --example=<name>`.
+- [Camel CLI Examples](https://github.com/apache/camel-jbang-examples):
Ready-to-run examples organised as a ladder of groups — run, transform, route,
fail well, connect, contracts and security, AI and cloud — each with a README
that says what you will see, how it works and how to build it step by step;
most also have a Citrus test. Run one with `camel run --example=<name>`.
### Who Is This For
The Camel CLI and TUI are designed for all developers, not just Java experts:
- **Integration developers** — build and test routes with instant feedback, no
compilation
-- **DevOps and platform engineers** — monitor and operate integrations from
any terminal, including over SSH
+- **DevOps and platform engineers** — run, test and export integrations from
any terminal, including over SSH
- **Non-Java developers** — write YAML routes and Groovy transformations
without Java knowledge
- **AI-assisted development** — AI agents generate routes, developers validate
them in the CLI/TUI workflow
- **Architects evaluating Camel** — go from zero to running integration in
under 60 seconds with `camel run route.yaml`
@@ -401,12 +403,12 @@ Camel provides multiple levels of error handling.
Understanding when to use each
## Observability
- **[Health Checks](https://camel.apache.org/manual/health-check.md)** —
built-in readiness and liveness checks for routes, consumers, and components.
Integrates with Spring Boot Actuator and Quarkus health endpoints for
Kubernetes probes.
--
**[OpenTelemetry](https://camel.apache.org/components/next/others/opentelemetry.md)**
— distributed tracing. Each route and EIP creates spans automatically.
Integrates with Jaeger, Zipkin, and any OpenTelemetry-compatible backend.
+-
**[OpenTelemetry](https://camel.apache.org/components/next/others/opentelemetry2.md)**
— distributed tracing. Each route and EIP creates spans automatically.
Integrates with Jaeger, Zipkin, and any OpenTelemetry-compatible backend.
-
**[Micrometer](https://camel.apache.org/components/next/micrometer-component.md)**
— metrics collection. Route-level and exchange-level metrics (throughput,
latency, error rate) automatically collected per route and processor.
-
**[Prometheus](https://camel.apache.org/components/next/others/micrometer-prometheus.md)**
— Micrometer metrics are exposed via a Prometheus endpoint. With
[camel-observability-services](https://camel.apache.org/components/next/others/observability-services.md),
Camel Main, Spring Boot and Quarkus expose them at `/observe/metrics` (health
at `/observe/health`) on the management port. Without it, Spring Boot Actuator
uses `/actuator/prometheus` and Quarkus `/q/metrics`. Scrape these wit [...]
- **[GenAI
Observability](https://camel.apache.org/components/next/others/ai-observability.md)**
— OpenTelemetry spans and Micrometer metrics for LLM calls (model, tokens,
latency) from the Camel AI components: OpenAI, LangChain4j and Spring AI. See
the blog posts on [the Camel CLI and
TUI](https://camel.apache.org/blog/2026/09/camel-genai-observability-jbang/)
and [Spring
Boot](https://camel.apache.org/blog/2026/09/camel-genai-observability-spring-boot/).
- **[Message
History](https://camel.apache.org/components/next/eips/message-history.md)** —
tracks which processors an exchange passed through. Useful for debugging
complex routes.
-- **[Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md)** —
terminal-based monitoring dashboard with live route topology, message history,
health checks, and OpenTelemetry spans.
+- **[Camel TUI](https://camel.apache.org/manual/camel-jbang-tui.md)** — a
developer tool: a terminal dashboard with live route topology, message history,
health checks, and OpenTelemetry spans while you build and test. Not for
production monitoring.
## Deployment
@@ -434,7 +436,7 @@ Both runtimes use the same Camel routes, components, and
EIPs — only the depen
## Components and Patterns
- [Components Index](https://camel.apache.org/components/next/index.md):
Complete list of all Camel connectors (350+).
-- [Enterprise Integration Patterns
(EIPs)](https://camel.apache.org/components/next/eips/index.md): 65+ message
routing and transformation patterns.
+- [Enterprise Integration Patterns
(EIPs)](https://camel.apache.org/components/next/eips/enterprise-integration-patterns.md):
65+ message routing and transformation patterns.
- [AI Patterns](https://camel.apache.org/components/next/eips/ai-patterns.md):
Common AI and modern design pattern terms mapped to Camel EIPs — fan-out,
scatter-gather, circuit breaker, retry, tokenize, and more.
- [YAML DSL](https://camel.apache.org/components/next/others/yaml-dsl.md):
Writing Camel routes in YAML — syntax, structure, and examples.
- [YAML DSL
Schema](https://github.com/apache/camel/blob/main/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json):
Complete JSON Schema for YAML DSL routes — the canonical spec for validating
and generating Camel YAML.
@@ -447,7 +449,7 @@ Both runtimes use the same Camel routes, components, and
EIPs — only the depen
- [Switch EIP](https://camel.apache.org/components/next/eips/switch-eip.md):
evaluates a selector once and dispatches to a fixed endpoint by literal value —
a decision table, simpler than `choice` when every branch compares the same
value.
- [Cache EIP](https://camel.apache.org/components/next/eips/cache-eip.md):
read-through caching of a block of steps; on a cache hit the block is skipped
and the body comes from the cache.
-- [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md)
and [TypeSafe
AI](https://camel.apache.org/components/next/typesafe-ai-component.md): ask
named questions about message content to get decisions, categories and scores —
classify, score, validate and route by meaning. Jev, TypeSafe AI's System One
model, answers these as fast, structured decisions instead of generated text
(see [semantic decisions with Jev](https://camel.apache.org/blog/2026/09 [...]
+- [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md)
and [TypeSafe
AI](https://camel.apache.org/components/next/typesafe-ai-component.md): ask
named questions about message content to get decisions, categories and scores —
classify, score, validate and route by meaning. Jev, TypeSafe AI's System One
model, answers these as fast, structured decisions instead of generated text,
and the Wolf Defender expert detects prompt injection locally (see [sem [...]
- [LangChain4j
Ingest](https://camel.apache.org/components/next/langchain4j-ingest-component.md)
(split, embed and store documents for RAG), [AI
Resource](https://camel.apache.org/components/next/ai-resource-component.md) (a
route as a read-only AI resource), [AI
Observability](https://camel.apache.org/components/next/others/ai-observability.md).
- Security for agents and services:
[OPA](https://camel.apache.org/components/next/opa-component.md) (Rego
policies),
[OpenFGA](https://camel.apache.org/components/next/openfga-component.md)
(relationship-based authorization),
[SPIFFE](https://camel.apache.org/components/next/spiffe-component.md)
(workload identity and rotating mutual TLS) — see [Authorizing what an AI agent
may do](https://camel.apache.org/blog/2026/09/securing-ai-agent-tools/) and
[Workload identity with SPIFFE](https: [...]
- Connectors:
[OData](https://camel.apache.org/components/next/odata-component.md),
[HiveMQ](https://camel.apache.org/components/next/hivemq-component.md), [State
Store](https://camel.apache.org/components/next/state-store-component.md)
(pluggable key-value store), [REST
Postman](https://camel.apache.org/components/next/rest-postman-component.md) (a
Postman collection as REST contract), and Alibaba Cloud (OSS, MNS, FC, SMS,
KMS, EventBridge, SLS, Tablestore).
@@ -461,7 +463,7 @@ Apache Camel supports two tiers of AI agent connectivity:
an embedded mode, wher
Expose Camel routes as AI agent tools directly from the Camel process — one
command, zero infrastructure. This is the fastest way to make an integration
AI-accessible.
-- [AI Tool](https://camel.apache.org/components/next/ai-tool-component.md) and
[MCP Server
component](https://camel.apache.org/components/next/others/mcp-server.md):
define a tool once as a Camel route (`from: ai-tool:...`) and it works with
LangChain4j, Spring AI and OpenAI; tag it and the built-in MCP server exposes
it to any MCP client. See [Camel Routes as AI
Tools](https://camel.apache.org/blog/2026/08/camel-ai-tools-mcp-422/).
+- [AI Tool](https://camel.apache.org/components/next/ai-tool-component.md) and
[MCP Server
component](https://camel.apache.org/components/next/others/mcp-server.md):
define a tool once as a Camel route (`from: ai-tool:...`) and it works with
LangChain4j, Spring AI and OpenAI; tag it and the built-in MCP server (Stable
since Camel 4.22, configured with `camel.server.mcp-*` properties) exposes it
to any MCP client. A tool can return structured output (`outputSchema`), and
the [AI Resource] [...]
- [Camel MCP Server for coding
assistants](https://camel.apache.org/manual/camel-jbang-mcp.md): a different
MCP server, in the Camel CLI (`camel mcp`), for building integrations: it
serves the Camel catalog — 350+ component schemas, EIP metadata, validated
samples and YAML validation — so AI coding assistants (Claude Code, GitHub
Copilot, Cursor, Gemini CLI) can generate correct, validated Camel routes.
- [Camel A2A](https://camel.apache.org/components/next/a2a-component.md):
Agent-to-Agent (A2A) protocol component — expose Camel routes as A2A agents or
call remote A2A agents. Supports HTTP+JSON and JSONRPC bindings,
OAuth/OIDC/API-key auth, and SSE streaming.
@@ -471,8 +473,8 @@ The model is not a security boundary, so the decision about
what an agent may do
- **Who is calling:**
[SPIFFE](https://camel.apache.org/components/next/spiffe-component.md) gives
every workload a cryptographic identity from the local SPIRE agent, plus
rotating mutual TLS for the components that already support TLS. See [Workload
identity with SPIFFE and
SPIRE](https://camel.apache.org/blog/2026/09/camel-spiffe-workload-identity/).
- **What they may do:** set an `authorizationPolicy` on an `ai-tool:` route
and every tool call is authorized before it runs; a denied call is returned to
the model as a short refusal it can relay. Policies with [Open Policy
Agent](https://camel.apache.org/components/next/opa-component.md) (Rego) or
[OpenFGA](https://camel.apache.org/components/next/openfga-component.md)
(relationship-based). See [Authorizing what an AI agent may
do](https://camel.apache.org/blog/2026/09/securing-ai-agen [...]
-- **Fast guard decisions:** the [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md)
with Jev, a System One model ([TypeSafe
AI](https://camel.apache.org/components/next/typesafe-ai-component.md)) checks
whether an action fits the approved task, or scores a contribution, as a
yes/no, category or score inside `choice`, `switch` or `filter`.
-- **What happened:** [AI
Observability](https://camel.apache.org/components/next/others/ai-observability.md)
records OpenTelemetry GenAI spans and Micrometer metrics for every LLM call,
next to the route's own traces. See [Observe your Camel AI
routes](https://camel.apache.org/blog/2026/09/camel-genai-observability-jbang/).
+- **Fast guard decisions:** the [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md)
with Jev, a System One model ([TypeSafe
AI](https://camel.apache.org/components/next/typesafe-ai-component.md)) checks
whether an action fits the approved task, or scores a contribution, as a
yes/no, category or score inside `choice`, `switch` or `filter`. [Wolf
Defender](https://camel.apache.org/components/next/others/semantic-wolf-defender.md)
detects prompt inje [...]
+- **What happened:** [AI
Observability](https://camel.apache.org/components/next/others/ai-observability.md)
records OpenTelemetry GenAI spans and Micrometer metrics for every LLM call,
next to the route's own traces. `camel run --observe` adds it automatically
when a route uses AI components. See [Observe your Camel AI
routes](https://camel.apache.org/blog/2026/09/camel-genai-observability-jbang/).
### Tier 2: Governed agent access (Wanaku)
@@ -486,12 +488,64 @@ The same `ai-tool:` routes work at both tiers. Develop
and test them with the Ca
### AI components
- [AI Patterns](https://camel.apache.org/components/next/eips/ai-patterns.md):
Common AI and modern design pattern terms mapped to Camel EIPs — fan-out,
scatter-gather, circuit breaker, retry, tokenize, and more.
-- [Camel
LangChain4j](https://camel.apache.org/components/next/langchain4j-chat-component.md):
LLM integration via LangChain4j — connect Camel routes to large language
models.
-- [Camel
OpenAI](https://camel.apache.org/components/next/openai-component.md): Native
OpenAI component for calling OpenAI APIs from Camel routes.
+- [Camel
LangChain4j](https://camel.apache.org/components/next/langchain4j-chat-component.md):
LLM integration via LangChain4j — connect Camel routes to large language
models. The [LangChain4j
Agent](https://camel.apache.org/components/next/langchain4j-agent-component.md)
component adds tool calling, moderation and tool-calling limits. Models can be
configured with properties only, for example
`camel.component.langchain4j-agent.provider=ollama` with `modelName` and
`baseUrl`.
+- [LLM
(OpenAI-compatible)](https://camel.apache.org/components/next/openai-component.md):
the `llm:` component (with `openai:` as an alias) for OpenAI and any
OpenAI-compatible API, such as OpenRouter, Ollama, vLLM and LM Studio. It also
covers moderation (block a flagged message before it reaches the model), the
[Batch API](https://camel.apache.org/components/next/others/openai-batch.md)
(asynchronous, at half the price), the Responses API with hosted tools, MCP
tool calling with a tok [...]
+- [Spring
AI](https://camel.apache.org/components/next/spring-ai-chat-component.md):
chat, embeddings, image and vector store components on Spring AI 2.0 (Spring
Boot 4.1).
- [LangChain4j
Ingest](https://camel.apache.org/components/next/langchain4j-ingest-component.md):
Split, embed and store documents into an embedding store for
retrieval-augmented generation.
-- [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md):
Decisions, categories and scores about message content, for routing and
filtering by meaning. Answered by a provider adapter; today that is Jev, a
System One model, via [TypeSafe
AI](https://camel.apache.org/components/next/typesafe-ai-component.md).
+- [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md):
Decisions, categories, scores and labels about message content, for routing
and filtering by meaning. See the next section.
- [AI
Observability](https://camel.apache.org/components/next/others/ai-observability.md):
OpenTelemetry spans and Micrometer metrics for every LLM call.
+### Semantic decisions with System One models
+
+A System One model gives fast, structured decisions instead of generated text:
give it the relevant state and a question, and it returns a category, a score
or a probability that the route can use directly. Jev, from TypeSafe AI, is
such a model. Camel uses it through the [Semantic
language](https://camel.apache.org/components/next/languages/semantic-language.md)
(Preview since Camel 4.23):
+
+- Declare named evaluations once: a yes/no decision, a choice of category, a
score, or a set of labels. Use them wherever Camel accepts an expression or
predicate: `choice`, `filter`, `switch`, `validate`, aggregate correlation and
completion, `recipientList`, `loop`, and `onException` `retryWhile`.
+- Use an evaluation with `ref:name` in the semantic language, or with
`${semantic('name')}` in Simple. `refs:a,b,c` asks several questions in one
call and returns a map of named answers; the result metadata, including the
probabilities, is in `CamelSemanticResults`.
+- Each evaluation names an *expert*: a pluggable adapter, registered as a
bean. An expert is a configured evaluator, not an autonomous agent. [TypeSafe
AI](https://camel.apache.org/components/next/typesafe-ai-component.md) asks Jev
(yes/no, choice and score questions, with probabilities; set
`camel.component.typesafe-ai.api-key`). [Wolf
Defender](https://camel.apache.org/components/next/others/semantic-wolf-defender.md)
detects prompt injection and jailbreak attempts locally on the CPU, [...]
+- Decisions can be audited (opt-in): `camel semantic audit`, the developer
console, and the Semantic tab in the Camel TUI.
+- Version notes: the YAML syntax changed during 4.23 (`question:` became
`evaluation:`). From 4.24 every evaluation must name its `expert` (the
`semantic:` block no longer sets a default), and the providers move to
`camel-semantic-typesafe-ai` and `camel-semantic-wolf-defender` (in 4.23:
`camel-typesafe-ai` and `camel-wolf-defender`). The example below works in both
versions.
+
+```yaml
+# application.properties:
+#
camel.beans.decisions=#class:org.apache.camel.component.typesafeai.TypeSafeAiSemanticAdapter
+# camel.component.typesafe-ai.api-key=<your key>
+- semantic:
+ state: "${body}"
+ evaluation:
+ department:
+ expert: decisions
+ type: choice
+ parameters:
+ instructions: Which department should handle this message?
+ criteria:
+ billing: Invoices, payments and refunds
+ technical: Bugs, outages and technical problems
+- route:
+ from:
+ uri: direct:tickets
+ steps:
+ - setProperty:
+ name: department
+ expression:
+ language:
+ language: semantic
+ expression: ref:department
+ - choice:
+ when:
+ - expression:
+ simple:
+ expression: "${exchangeProperty.department} == 'billing'"
+ steps:
+ - to:
+ uri: direct:billing
+ otherwise:
+ steps:
+ - to:
+ uri: direct:review
+```
+
+See [semantic decisions with
Jev](https://camel.apache.org/blog/2026/09/semantic-evaluation-system-one/),
and [semantic agent
routing](https://camel.apache.org/blog/2026/10/semantic-agent-routing/), which
coordinates several A2A agents with semantic decisions and bounded retries.
+
## Tooling
- [Tooling Overview](https://camel.apache.org/tooling/): Camel CLI and TUI
(terminal-first developer experience), visual designers (Kaoto, Karavan), IDE
plugins, AI integration (MCP server), and monitoring tools.
@@ -517,7 +571,7 @@ The same `ai-tool:` routes work at both tiers. Develop and
test them with the Ca
For high-quality answers about routing, code generation, and troubleshooting,
AI models should understand these areas in depth:
-- **Enterprise Integration Patterns (EIPs)** — the 65+ patterns and their
Camel implementations, not just names but trade-offs and when to use each. See
[EIPs](https://camel.apache.org/components/next/eips/index.md).
+- **Enterprise Integration Patterns (EIPs)** — the 65+ patterns and their
Camel implementations, not just names but trade-offs and when to use each. See
[EIPs](https://camel.apache.org/components/next/eips/enterprise-integration-patterns.md).
- **Endpoint URIs and Components** — syntax, parameters, and how to discover
them via the catalog (350+ connectors). See
[Components](https://camel.apache.org/components/next/index.md).
- **DSLs** — YAML (declarative structure, nesting rules) and Java DSL
differences; YAML is preferred for new examples and AI-assisted development.
- **Message Model** — Exchange, headers vs. properties vs. variables, type
conversion, data formats. See [Core Concepts](#core-concepts) above.
@@ -558,10 +612,9 @@ For high-quality answers about routing, code generation,
and troubleshooting, AI
- [Blog](https://camel.apache.org/blog/index.md): Index of every blog post
with its date and summary; each post is available as Markdown at its URL plus
`index.md`, for example
`https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/index.md`.
- [Camel by the
Numbers](https://camel.apache.org/blog/2026/06/camel-by-the-numbers/):
Data-driven overview — commits, contributors, release cadence, bug fix times,
and community health metrics.
- [The DNA of Apache
Camel](https://camel.apache.org/blog/2026/06/camel-dna-19-years/): 19 years of
backwards compatibility — why Camel users don't have to rewrite their
integrations every few years.
-- [Who Maintains Apache
Camel](https://camel.apache.org/blog/2026/07/camel-who-maintains/):
Year-by-year commit data showing who maintains the project — the same core
team, through multiple acquisitions, contributing 80–95% of all commits every
year since 2007.
+- [Who Maintains Apache
Camel](https://camel.apache.org/blog/2026/07/camel-who-maintains/):
Year-by-year commit data showing who maintains the project — the same core
team, through multiple acquisitions, contributing 78–96% of all commits every
year since 2009.
- [Apache Camel Is Not Afraid of
AI](https://camel.apache.org/blog/2026/07/camel-not-afraid-of-ai/): The project
pointed a frontier AI model at 19 years of code and fixed all 165 bugs it found
— concurrency races, silent data loss, security gaps. AI-assisted code review
is now a standard part of the development process.
-- [A frontier AI coached a small local model through
Camel](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/):
Measured benchmark of a frontier model (13 of 13 beginner examples) and a 22 GB
local model on a laptop (0 to 12 of 13 over twenty runs) building Camel routes
with the MCP server, and the 117 findings — 99 of them wrong for humans too —
fixed in Camel 4.23: error messages that say what to write, validation at write
time, catalog samples, a stricter YAML schema.
-- [Round 2 of the local-model
benchmark](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark-round-2/):
Real-world examples built step by step through the MCP server, 81% to 92% of
steps passed, and 31 more fixes in Camel 4.23 (a failed reload keeps the
previous routes, the runtime prints the validator's report, the MCP write tool
reports the reload outcome).
+- [The local model benchmark
series](https://camel.apache.org/blog/2026/10/camel-local-model-benchmark-round-4/):
Four rounds (September–October 2026) of a frontier model coaching a local
model on a 64 GB Mac mini through Camel, where every failure became a fix in
Camel: beginner examples (0 to 12 of 13), real-world examples built step by
step (81% to 92% of steps), Kamelets (1 of 15 to 47 of 50 steps), and
intermediate examples with Kafka, JMS, REST and an LLM (37% to 64% in three
night [...]
- [The Camel website, rebuilt for humans and for
AI](https://camel.apache.org/blog/2026/09/camel-website-rebuilt/): Why every
page has a Markdown mirror and an offline bundle, and how the site gets a
person or an AI agent to a running route.
- [Built to Patch
Fast](https://camel.apache.org/blog/2026/07/camel-security-advisories-4.21.0/):
How the project handled 32 CVEs in one release — the timeline, the backport
process, incomplete fixes re-issued as new CVEs, and 31 public PoC reproducers.
The best single-page overview of Camel's security response in practice.
- [Security](https://camel.apache.org/security/): Security advisories and
vulnerability reports.
diff --git a/static/camel-cli/releases/latest.properties
b/static/camel-cli/releases/4.14.9.properties
similarity index 85%
copy from static/camel-cli/releases/latest.properties
copy to static/camel-cli/releases/4.14.9.properties
index 5ef63e30..101d85b0 100644
--- a/static/camel-cli/releases/latest.properties
+++ b/static/camel-cli/releases/4.14.9.properties
@@ -15,6 +15,6 @@
## limitations under the License.
## ---------------------------------------------------------------------------
format=1
-version=4.22.1
-tar_sha256=9046da0191b93b81e7caddde0d4e4e48de29d7cccbd043b1feb7987c14de0007
-zip_sha256=85df65e79f5d9ac83200bf1085de8fed3213b8e78ed33112e793a3ee81334c52
+version=4.14.9
+tar_sha256=7424eb9f925262292a0b57bf47a7ebdc8e65a666cee92357a2e8938e1dfbae13
+zip_sha256=3c9258a146f3e9ba19749d1ec8c9a0e3de96baa9af12b8fc8448202942dc7c4b
diff --git a/static/camel-cli/releases/latest.properties
b/static/camel-cli/releases/4.18.4.properties
similarity index 85%
copy from static/camel-cli/releases/latest.properties
copy to static/camel-cli/releases/4.18.4.properties
index 5ef63e30..6b53e061 100644
--- a/static/camel-cli/releases/latest.properties
+++ b/static/camel-cli/releases/4.18.4.properties
@@ -15,6 +15,6 @@
## limitations under the License.
## ---------------------------------------------------------------------------
format=1
-version=4.22.1
-tar_sha256=9046da0191b93b81e7caddde0d4e4e48de29d7cccbd043b1feb7987c14de0007
-zip_sha256=85df65e79f5d9ac83200bf1085de8fed3213b8e78ed33112e793a3ee81334c52
+version=4.18.4
+tar_sha256=bbf5b94a241f910379730bc07ad6bfe9f2592b3bb80ba7cd3dd2815c310654bd
+zip_sha256=3f1c709fdcfe29a721cd0635e0f689b3379c55e3622fcb5788553c090b5b7c12
diff --git a/static/camel-cli/releases/latest.properties
b/static/camel-cli/releases/4.18.5.properties
similarity index 85%
copy from static/camel-cli/releases/latest.properties
copy to static/camel-cli/releases/4.18.5.properties
index 5ef63e30..c3d841a7 100644
--- a/static/camel-cli/releases/latest.properties
+++ b/static/camel-cli/releases/4.18.5.properties
@@ -15,6 +15,6 @@
## limitations under the License.
## ---------------------------------------------------------------------------
format=1
-version=4.22.1
-tar_sha256=9046da0191b93b81e7caddde0d4e4e48de29d7cccbd043b1feb7987c14de0007
-zip_sha256=85df65e79f5d9ac83200bf1085de8fed3213b8e78ed33112e793a3ee81334c52
+version=4.18.5
+tar_sha256=69416c52cf97a13866f90dcb96e0fae8bbecf12946d51268ab713b23a28d8d2f
+zip_sha256=be224addb60e47896cfd79e119b878d41cfe1641a6d98b883f8805e71b447366
diff --git a/static/camel-cli/releases/latest.properties
b/static/camel-cli/releases/4.22.2.properties
similarity index 85%
copy from static/camel-cli/releases/latest.properties
copy to static/camel-cli/releases/4.22.2.properties
index 5ef63e30..d08aa63c 100644
--- a/static/camel-cli/releases/latest.properties
+++ b/static/camel-cli/releases/4.22.2.properties
@@ -15,6 +15,6 @@
## limitations under the License.
## ---------------------------------------------------------------------------
format=1
-version=4.22.1
-tar_sha256=9046da0191b93b81e7caddde0d4e4e48de29d7cccbd043b1feb7987c14de0007
-zip_sha256=85df65e79f5d9ac83200bf1085de8fed3213b8e78ed33112e793a3ee81334c52
+version=4.22.2
+tar_sha256=df23414b5a817f1dfe63b6618b0afa47eb01e272f89d90f41a826f28f75c5e1e
+zip_sha256=434dd3a0ef30e87d540c00047a13e379e1dba33dd920b4c2b7affc3bbb999fc1
diff --git a/static/camel-cli/releases/latest.properties
b/static/camel-cli/releases/4.23.0.properties
similarity index 85%
copy from static/camel-cli/releases/latest.properties
copy to static/camel-cli/releases/4.23.0.properties
index 5ef63e30..8f7c638e 100644
--- a/static/camel-cli/releases/latest.properties
+++ b/static/camel-cli/releases/4.23.0.properties
@@ -15,6 +15,6 @@
## limitations under the License.
## ---------------------------------------------------------------------------
format=1
-version=4.22.1
-tar_sha256=9046da0191b93b81e7caddde0d4e4e48de29d7cccbd043b1feb7987c14de0007
-zip_sha256=85df65e79f5d9ac83200bf1085de8fed3213b8e78ed33112e793a3ee81334c52
+version=4.23.0
+tar_sha256=d81b341141f29323932be6a1010027f4968634b9fded4c6eac6750920fa387af
+zip_sha256=2fa53a229fb5ef8e819cbc24a015d75a16105c9c0b7897742d13adea1695c8e5
diff --git a/static/camel-cli/releases/latest.properties
b/static/camel-cli/releases/latest.properties
index 5ef63e30..8f7c638e 100644
--- a/static/camel-cli/releases/latest.properties
+++ b/static/camel-cli/releases/latest.properties
@@ -15,6 +15,6 @@
## limitations under the License.
## ---------------------------------------------------------------------------
format=1
-version=4.22.1
-tar_sha256=9046da0191b93b81e7caddde0d4e4e48de29d7cccbd043b1feb7987c14de0007
-zip_sha256=85df65e79f5d9ac83200bf1085de8fed3213b8e78ed33112e793a3ee81334c52
+version=4.23.0
+tar_sha256=d81b341141f29323932be6a1010027f4968634b9fded4c6eac6750920fa387af
+zip_sha256=2fa53a229fb5ef8e819cbc24a015d75a16105c9c0b7897742d13adea1695c8e5
