This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch chore/llms-txt-refresh
in repository https://gitbox.apache.org/repos/asf/camel-website.git

commit 8d8fd7c9ec998a5a34d440056adf2c2440d7bc1b
Author: Claus Ibsen <[email protected]>
AuthorDate: Thu Nov 19 22:53:43 2026 +0100

    chore: llms.txt - remove Wanaku, add Camel 4.24 (in development), link 
recent blog posts
    
    - Remove Wanaku (Tier 2 governed proxy) from the AI integration section and 
key facts
    - Java 21 is the minimum from Camel 4.24
    - Add a "Coming in Camel 4.24" section: faster CLI on aesh with an 
exit-code contract,
      Chaos, Test DST, Sanitizer, AI Prompt, Cedar, Semantic OpenAI/Micrometer, 
new connectors,
      removed OGNL and WASM languages
    - Link new CLI manual pages (exit codes, Java API, TUI ways to use AI, TUI 
recording)
      and the `camel status` command
    - Tooling: IDE plugins, Maven plugins, hawt.io
    - Link recent blog posts on testing, RAG, Camel 4.23, security advisories 
and CI
    
    Co-Authored-By: Claude Opus 5.5 <[email protected]>
---
 llms-txt-template.md | 58 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/llms-txt-template.md b/llms-txt-template.md
index e782140e..211af71f 100644
--- a/llms-txt-template.md
+++ b/llms-txt-template.md
@@ -44,7 +44,7 @@ The `catalog/` JSON files contain machine-readable metadata 
for every connector/
 - 350+ connectors included out of the box: Kafka, REST, JDBC, AWS (S3, SQS, 
Lambda), Azure, GCP, Salesforce, MongoDB, AMQP, FTP/SFTP, and many more
 - 65+ Enterprise Integration Patterns (EIPs) for routing, transformation, and 
error handling
 - 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`
+- Install the Camel CLI with `curl -fsSL https://camel.apache.org/install.sh | 
sh` (needs Java 17+, and Java 21+ from Camel 4.24; 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 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)
@@ -53,7 +53,7 @@ The `catalog/` JSON files contain machine-readable metadata 
for every connector/
 - 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
+- AI agent connectivity built into the route: expose Camel routes as MCP tools 
(`camel-ai-tool` + `camel-mcp-server`) and as A2A agents, with workload 
identity, authorization policies and GenAI observability on every tool call
 - 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 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 [...]
@@ -328,6 +328,7 @@ This is the recommended starting point for all developers, 
including those who a
 - [`camel cmd send`](https://camel.apache.org/manual/camel-jbang-devtools.md): 
Send a test message to any endpoint in a running integration. Test routes 
interactively without writing test code — send a message and watch it flow 
through `camel trace`.
 - [`camel test`](https://camel.apache.org/manual/camel-jbang-test.md): Run 
integration tests directly from the CLI with the Citrus test framework, 
including infrastructure services started for the test.
 - [`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 
status`](https://camel.apache.org/manual/jbang-commands/camel-jbang-status.md): 
The state of a running integration in one call — routes, health, last errors 
and reload, JVM, and the end of its log. With `--json` it is the quickest way 
for an AI agent to check an integration (since Camel 4.24).
 - [`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 a Maven build, ready for CI/CD 
pipelines and container deployment. Start fast with the CLI, ship to production 
on an enterprise runtime.
@@ -345,12 +346,14 @@ This is the recommended starting point for all 
developers, including those who a
 - [AI Tools](https://camel.apache.org/manual/camel-jbang-ai.md) (`camel ask`, 
`camel explain`, `camel overview`, `camel harden`) and [AI Providers and Local 
Models](https://camel.apache.org/manual/camel-jbang-ai-providers.md) (Ollama 
and OpenAI-compatible servers)
 - [Export to Maven](https://camel.apache.org/manual/camel-jbang-projects.md): 
Spring Boot, Quarkus or Camel Main projects, plugins, version management
 - [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)
+- [Exit Codes and 
Output](https://camel.apache.org/manual/camel-jbang-exit-codes.md): the 
contract scripts, CI jobs and AI agents can rely on — exit codes, errors on 
stderr, one JSON document on stdout with `--json`, and `--timeout` (since Camel 
4.24)
+- [Java API for Export and 
Run](https://camel.apache.org/manual/camel-jbang-java-api.md): run and export 
from an IDE, a visual designer or an AI agent without starting the `camel` 
command (since Camel 4.24, preview)
 - 
[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 Dashboard for Developers
 
 - [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  
[...]
+- 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), 
[Ways to Use AI](https://camel.apache.org/manual/camel-jbang-tui-ai-ways.md), 
[AI Panel](https://camel.apache.org/manual/camel-jbang-tui-ai.md), [Local  [...]
 - 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).
 
@@ -361,6 +364,7 @@ This is the recommended starting point for all developers, 
including those who a
 - 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 [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`).
+- Since Camel 4.24 the CLI is built for an agent that calls it 50 or 100 times 
per task: a command takes about 125 ms instead of more than a second, and the 
[exit codes and 
output](https://camel.apache.org/manual/camel-jbang-exit-codes.md) are a 
contract an agent can act on. See [The Camel CLI in Camel 
4.24](https://camel.apache.org/blog/2026/11/camel-cli-424/).
 - 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
@@ -397,8 +401,11 @@ Camel provides multiple levels of error handling. 
Understanding when to use each
 - **[CamelTestSupport](https://camel.apache.org/manual/testing.md)** — base 
class for JUnit 5 tests. Provides a `CamelContext`, `ProducerTemplate`, and 
`MockEndpoint` setup out of the box.
 - **[Mock 
Component](https://camel.apache.org/components/next/mock-component.md)** — 
assert that endpoints receive the expected number of messages with the expected 
content. Use `getMockEndpoint("mock:result").expectedMessageCount(1)`.
 - **[AdviceWith](https://camel.apache.org/manual/advice-with.md)** — modify 
routes for testing without changing production code. Replace endpoints, add 
interceptors, or simulate errors. Essential for testing routes that talk to 
external systems.
-- **[`camel test`](https://camel.apache.org/manual/camel-jbang-test.md)** — 
integration tests from the Camel CLI with the Citrus test framework, written in 
YAML, with infrastructure services started for the test.
+- **[`camel test`](https://camel.apache.org/manual/camel-jbang-test.md)** — 
integration tests from the Camel CLI with the Citrus test framework, written in 
YAML, with infrastructure services started for the test. See [Fast and easy 
integration testing with the Camel CLI Test 
Plugin](https://camel.apache.org/blog/2026/10/camel-yaml-dsl-testing/).
 - **[Test Infra](https://camel.apache.org/manual/test-infra.md)** — 
Testcontainers-based test infrastructure for databases, message brokers, and 
cloud services. Use `@RegisterExtension` with service factories (e.g., 
`KafkaServiceFactory`, `JDBCServiceFactory`).
+- **[Chaos](https://camel.apache.org/components/next/others/chaos.md)** — turn 
on faults in a running application during development ("fail 30% of the sends 
to `kafka:orders` for one minute") and get a report of how `onException`, 
redelivery and the dead letter channel coped; `camel cmd chaos-explore` lets an 
AI explore the faults by itself. Development only (since Camel 4.24).
+- **[Test DST](https://camel.apache.org/components/next/others/test-dst.md)** 
— deterministic simulation testing for consumers: a seeded virtual-time 
scheduler, fault injection, invariants and seed replay (since Camel 4.24). The 
[Sanitizer](https://camel.apache.org/components/next/others/sanitizer.md) 
checks during development and tests that processors keep the `AsyncProcessor` 
contract and that consumer commits run exactly once.
+- **[Camel Integration Testing 
Pitfalls](https://camel.apache.org/blog/2026/10/camel-testing-pitfalls/)** — 
common mistakes when testing Camel routes and how to avoid them.
 
 ## Observability
 
@@ -447,6 +454,8 @@ Both runtimes use the same Camel routes, components, and 
EIPs — only the depen
 
 ### New in Camel 4.23
 
+See [Apache Camel 4.23 What's 
New](https://camel.apache.org/blog/2026/10/camel423-whatsnew/) for the full 
overview.
+
 - [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, 
and the Wolf Defender expert detects prompt injection locally (see [sem [...]
@@ -455,15 +464,26 @@ Both runtimes use the same Camel routes, components, and 
EIPs — only the depen
 - 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).
 - Languages and data formats: [Python 
3](https://camel.apache.org/components/next/languages/python3-language.md), 
[QuickJS](https://camel.apache.org/components/next/languages/quickjs-language.md)
 (JavaScript), 
[TOON](https://camel.apache.org/components/next/dataformats/toon-dataformat.md) 
(Token-Oriented Object Notation), 
[UBL](https://camel.apache.org/components/next/dataformats/ubl-dataformat.md) 
(UBL 2.1 business documents).
 
+### Coming in Camel 4.24 (in development)
+
+The `next` documentation is the main branch, which becomes Camel 4.24. Check 
the [4.24 upgrade 
guide](https://camel.apache.org/manual/camel-4x-upgrade-guide-4_24.md) before 
relying on these in a released version.
+
+- **Java 21** is the minimum runtime version; Java 17 is no longer supported.
+- **Camel CLI**: about 10 times faster per command, now built on aesh instead 
of picocli, with [exit codes and 
output](https://camel.apache.org/manual/camel-jbang-exit-codes.md) as a 
contract, `camel status`, `camel get timeline`, and `camel cmd reload --wait 
--json`. See [The Camel CLI in Camel 
4.24](https://camel.apache.org/blog/2026/11/camel-cli-424/).
+- **Chaos and simulation testing**: 
[Chaos](https://camel.apache.org/components/next/others/chaos.md), [Test 
DST](https://camel.apache.org/components/next/others/test-dst.md) and 
[Sanitizer](https://camel.apache.org/components/next/others/sanitizer.md).
+- **AI**: [AI 
Prompt](https://camel.apache.org/components/next/ai-prompt-component.md) (a 
route as an MCP prompt template), 
[Cedar](https://camel.apache.org/components/next/cedar-component.md) (embedded 
authorization policies), the [OpenAI decisions 
expert](https://camel.apache.org/components/next/others/semantic-openai.md) and 
[Semantic 
Micrometer](https://camel.apache.org/components/next/others/semantic-micrometer.md)
 for the Semantic language.
+- **Connectors**: [Apicurio 
Registry](https://camel.apache.org/components/next/apicurio-registry-component.md),
 [AWS Parameter 
Store](https://camel.apache.org/components/next/aws-parameter-store-component.md),
 [Azure Event 
Grid](https://camel.apache.org/components/next/azure-eventgrid-component.md), 
[Azure IoT 
Hub](https://camel.apache.org/components/next/azure-iothub-component.md), 
[Hibernate](https://camel.apache.org/components/next/hibernate-component.md), 
[MTConnect](https://camel.ap [...]
+- **Removed**: the OGNL and WASM languages. `camel-observability-services` and 
`camel-lra` are promoted to Stable; `camel-openstack` is deprecated.
+
 ## AI Integration
 
-Apache Camel supports two tiers of AI agent connectivity: an embedded mode, 
where the Camel route itself exposes, identifies, authorizes and observes every 
agent tool call, and a governed proxy (Wanaku) in front of many routes across 
teams.
+Camel routes connect to AI agents directly: the route itself exposes, 
identifies, authorizes and observes every agent tool call.
 
-### Tier 1: Embedded AI protocols (developer mode)
+### Embedded AI protocols
 
 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 (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] [...]
+- [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.
 
@@ -472,26 +492,17 @@ Expose Camel routes as AI agent tools directly from the 
Camel process — one co
 The model is not a security boundary, so the decision about what an agent may 
do sits below it, on the tool call itself, evaluated in-process by the Camel 
route that does the work. No extra gateway is needed for this.
 
 - **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 [...]
+- **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) 
[OpenFGA](https://camel.apache.org/components/next/openfga-component.md) 
(relationship-based), or, from Camel 4.24, embedded 
[Cedar](https://camel.apache.org/components/next/cedar-component.md)  [...]
 - **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)
-
-When AI agents must never reach backend systems directly, and every tool call 
needs policy, identity, and audit enforced in between, put a governed proxy in 
front of your Camel routes.
-
-- [Wanaku](https://wanaku.ai/): A governed action proxy for AI agents 
(formerly the Wanaku MCP Router). It sits between agents and the systems they 
act on, intercepting MCP tool calls, agent-to-agent messages, and inference 
traffic. Policy evaluators, authentication and authorization, namespace 
isolation per team or tenant, and an admin dashboard. Apache License 2.0.
-- [Integration Capability for Apache 
Camel](https://github.com/wanaku-ai/camel-integration-capability): Publishes 
Camel routes as tools through Wanaku. It runs the routes with Camel's built-in 
MCP server, so routes using the `ai-tool:` URI become tools that agents call 
through the proxy.
-
-The same `ai-tool:` routes work at both tiers. Develop and test them with the 
Camel CLI (Tier 1), then publish them through Wanaku (Tier 2) when agents need 
governed access.
-
 ### 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. 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.
+- [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. See [Document Ingestion for RAG in Camel 
4.23](https://camel.apache.org/blog/2026/11/camel-document-ingestion-rag/) and 
[Building an Agentic RAG Application with Apache Camel and 
LangChain4j](https://camel.apache.org/blog/2026/10/agentic-rag-apache-camel/).
 - [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.
 
@@ -502,7 +513,7 @@ A System One model gives fast, structured decisions instead 
of generated text: g
 - 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.
+- Decisions can be audited (opt-in): `camel semantic audit`, the developer 
console, and the Semantic tab in the Camel TUI. From Camel 4.24, `camel 
semantic monitoring` and [Semantic 
Micrometer](https://camel.apache.org/components/next/others/semantic-micrometer.md)
 export the measurements as metrics.
 - 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
@@ -551,7 +562,10 @@ See [semantic decisions with 
Jev](https://camel.apache.org/blog/2026/09/semantic
 - [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.
 - [Kaoto](https://kaoto.io): Open source visual designer for Camel routes — 
drag-and-drop, no code required.
 - [Karavan](https://github.com/apache/camel-karavan): Visual designer for 
Camel integrations in VS Code and as a standalone application.
+- IDE plugins: the [Apache Camel IDEA 
Plugin](https://github.com/camel-tooling/camel-idea-plugin) for IntelliJ IDEA 
and the [VS Code Extension Pack for 
Camel](https://marketplace.visualstudio.com/items?itemName=redhat.apache-camel-extension-pack),
 both with route debugging.
+- Maven plugins: the [Camel Maven 
Plugin](https://camel.apache.org/manual/camel-maven-plugin.md) (`camel:run`, 
`camel:dev` with hot-reload), the [Camel Report Maven 
Plugin](https://camel.apache.org/manual/camel-report-maven-plugin.md) 
(validates endpoint URIs and Simple expressions, route coverage), and the [REST 
DSL OpenAPI plugin](https://camel.apache.org/manual/rest-dsl-openapi.md) 
(contract-first REST).
 - [Camel Monitor 
Operator](https://camel-tooling.github.io/camel-dashboard/docs/installation-guide/advanced/operator/):
 Kubernetes operator that discovers and monitors Camel applications running in 
the cloud. Lightweight dashboard with Prometheus integration.
+- [hawt.io](https://hawt.io): Web console for visualizing, managing and 
tracing Camel routes and endpoints, JMX, and more.
 
 ## Examples
 
@@ -578,7 +592,7 @@ For high-quality answers about routing, code generation, 
and troubleshooting, AI
 - **Message Model** — Exchange, headers vs. properties vs. variables, type 
conversion, data formats. See [Core Concepts](#core-concepts) above.
 - **Expression Languages** — especially the [Simple 
language](https://camel.apache.org/components/next/languages/simple-language.md),
 the most commonly used expression language in Camel routes.
 - **Resilience and Error Handling** — redelivery policies, dead letter 
channels, circuit breakers, compensation. See [Error 
Handling](https://camel.apache.org/manual/error-handler.md).
-- **Modern Tooling** — Camel CLI (`dev`, `validate`, `trace`, `send`, 
`export`, `kubernetes`, TUI), hot-reload workflow. See [Developer 
Experience](#developer-experience--cli-and-tui) above.
+- **Modern Tooling** — Camel CLI (`dev`, `validate`, `trace`, `send`, 
`status`, `export`, `kubernetes`, TUI), hot-reload workflow. See [Developer 
Experience](#developer-experience--cli-and-tui) above.
 - **Runtimes** — embedding in Spring Boot vs. Quarkus (native compilation, dev 
mode, starters). See [Runtimes](#runtimes) above.
 - **Testing and Observability** — mock endpoints, tracing, OpenTelemetry 
integration. See [Testing](https://camel.apache.org/manual/testing.md).
 - **AI Features** — MCP/A2A protocols, LLM components, exposing routes as AI 
agent tools. See [AI Integration](#ai-integration) above.
@@ -592,6 +606,7 @@ For high-quality answers about routing, code generation, 
and troubleshooting, AI
 - **Warn on version-specific features** — if a feature was introduced in a 
specific Camel version (e.g., variables in 4.4, route templates in 3.x), 
mention the version requirement.
 - **Validate generated routes** — use the [Camel MCP 
Server](https://camel.apache.org/manual/camel-jbang-mcp.md) or the [YAML DSL 
JSON 
Schema](https://github.com/apache/camel/blob/main/dsl/camel-yaml-dsl/camel-yaml-dsl/src/generated/resources/schema/camelYamlDsl-canonical.json)
 to verify generated YAML routes are structurally correct.
 - **Start from a sample, not from memory** — the Camel MCP server's catalog 
returns a validated YAML sample for any EIP or component by name. Fetch it 
before writing an EIP you have not used in this session; it is faster than a 
refused write and a guess.
+- **Trust the exit code** — since Camel 4.24, Camel CLI commands follow the 
[exit codes and 
output](https://camel.apache.org/manual/camel-jbang-exit-codes.md) contract: 
act on the exit code, read stdout as data (one JSON document with `--json`), 
and pass `--timeout` to commands that talk to a running integration.
 - **Apply the error message literally** — since Camel 4.23, validator, Simple 
parser and runtime messages state the correct form (e.g. "Operators go outside 
the function: `${body} contains 'critical'`"). Write exactly what the message 
says rather than a variation of it, then re-validate. See [Common 
mistakes](#common-mistakes) above.
 
 ## Sitemaps
@@ -617,7 +632,8 @@ For high-quality answers about routing, code generation, 
and troubleshooting, AI
 - [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.
 - [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.
+- [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. The 
latest round: [38 CVEs fixed in 4.18.5, 4.22.1 and 
4.23.0](https://camel.apache.org/blog/2026/10/camel-security-advisories-4.23.0/).
+- [Scaling the Apache Camel Core 
CI](https://camel.apache.org/blog/2026/11/camel-core-ci-improvements/): How the 
core CI went from a few green builds a year to reliable, faster feedback on 
every pull request.
 - [Security](https://camel.apache.org/security/): Security advisories and 
vulnerability reports.
 - [Security Model](https://camel.apache.org/manual/security-model.md): Apache 
Camel's built-in security model — route policy, payload validation, and how 
Camel protects against injection and untrusted input.
 - [Generating SBOMs](https://camel.apache.org/manual/sbom.html): How to 
generate Software Bill of Materials for Camel applications — Camel CLI, Spring 
Boot (built-in), and Quarkus. Every release since 4.0.3 ships with signed 
CycloneDX SBOMs.

Reply via email to