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 d7f84f25 Trust page and llms.txt: use the local model benchmark as
evidence that AI knows Camel
d7f84f25 is described below
commit d7f84f2501edb2c4ba93742a5bd1e6bb724ed1fd
Author: Claus Ibsen <[email protected]>
AuthorDate: Tue Sep 15 09:25:08 2026 +0200
Trust page and llms.txt: use the local model benchmark as evidence that AI
knows Camel
The "AI already knows Camel" box on the trust page now cites the measured
results from the local model benchmark blog (frontier model 13 of 13, local
model 0 to 12 of 13, 99 of 117 findings fixed for humans too in 4.23) and no
longer calls 4.22 LTS "upcoming".
llms.txt gets the same evidence in Key facts, AI-Assisted Development and
Additional Resources, plus a "Common mistakes" list under the YAML DSL
guidance built from the concrete before/after findings in the post, and two
recommended behaviours for agents: start from a catalog sample and apply the
error message literally.
Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>
---
content/trust/_index.md | 18 ++++++++++++++----
llms-txt-template.md | 21 +++++++++++++++++++++
2 files changed, 35 insertions(+), 4 deletions(-)
diff --git a/content/trust/_index.md b/content/trust/_index.md
index ecf4043c..4063775b 100644
--- a/content/trust/_index.md
+++ b/content/trust/_index.md
@@ -22,6 +22,10 @@ keywords:
- startup validation
- production mode
- insecure configuration
+- AI-assisted development
+- coding agents
+- MCP server
+- local models
---
Apache Camel has been running in production since 2007. Some of the largest
organizations in
@@ -301,10 +305,16 @@ lets LLMs generalize across 350+ connectors. Add a
built-in [MCP server](/manual
machine-readable catalog metadata, a schema-validated YAML DSL, and dedicated
[AI integration patterns](/components/next/eips/ai-patterns.html) for building
AI-powered
routes, and Camel is one of the best-trained integration frameworks for
AI-assisted development today.
-And it works both ways: for the upcoming 4.22 LTS release, we
-[pointed a frontier AI model at the
codebase](/blog/2026/07/camel-not-afraid-of-ai/) and fixed
-165 bugs it found — concurrency races, silent data loss, and security gaps
that are hard for
-humans to spot.
+
+We measure that rather than claim it. Given the Camel CLI as tools, a frontier
model
+[built all 13 beginner examples](/blog/2026/09/camel-local-model-benchmark/)
from a one-line
+description each. A 22 GB local model running on a laptop went from 0 of 13
with a bare prompt to
+12 of 13 once it had the Camel MCP server and error messages that say what to
write — and 99 of
+the 117 things it tripped over along the way were wrong for people too, so
they were fixed for
+everyone and ship in Camel 4.23. It works in the other direction as well: for
the 4.22 LTS
+release, we [pointed a frontier AI model at the
codebase](/blog/2026/07/camel-not-afraid-of-ai/)
+and fixed 165 bugs it found — concurrency races, silent data loss, and
security gaps that are
+hard for humans to spot.
<p>
<a class="button dark" href="/blog/2026/06/camel-ai-trained/">Read why</a>
diff --git a/llms-txt-template.md b/llms-txt-template.md
index cf0919d4..10e7b4d2 100644
--- a/llms-txt-template.md
+++ b/llms-txt-template.md
@@ -47,6 +47,7 @@ The `catalog/` JSON files contain machine-readable metadata
for every connector/
- Two tiers of AI agent connectivity: embedded MCP server (`camel mcp`) and
A2A protocol for developers, plus Wanaku enterprise MCP gateway for teams
managing many integrations at scale with governance, auth, and namespace
isolation
- 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 [...]
- Commercial support available from multiple vendors — see the commercial
support page
## Who maintains the project
@@ -262,6 +263,22 @@ See [Route
Templates](https://camel.apache.org/manual/route-template.md) for the
uri: kamelet:log-action
```
+### Common mistakes
+
+These are the errors models make most often when writing Camel YAML, taken
from [the local model
benchmark](https://camel.apache.org/blog/2026/09/camel-local-model-benchmark/).
Since Camel 4.23 the validator and the runtime report each of them with the
correct form; before that, check for them yourself.
+
+- The file must be a **list** (`- route:` / `- from:`), not a map. A map loads
zero routes without an error in older releases.
+- Simple operators go **outside** the function braces: `${body} contains
'critical'`, not `${body contains 'critical'}`. Text outside `${...}` is a
literal, so `body contains 'critical'` is a string, not a predicate — functions
are always written as `${body}`, `${header.name}`.
+- Bean methods use a dot or `?method=`: `${bean:myBean.getCount}` or
`${bean:myBean?method=getCount}`, never `${bean:myBean:getCount}` (the whole
`myBean:getCount` is looked up as the bean name).
+- `onException:` and `errorHandler:` are top-level list items placed before
the routes, not steps inside a route.
+- `handled` is a predicate, not a boolean: `handled: {constant: "true"}`.
+- `beans:` is a list where the name is a property: `- name: myBean` followed
by `type: "#class:com.example.MyBean"`, not a map keyed by bean name.
+- `mock:` is producer-only and cannot be a `from:`. To pass messages between
routes, send with `to: direct:name` and consume with `from: direct:name`.
+- `xslt:`, and other steps that transform the body, need a body: on a timer
route read the input first with `poll: file:...`, `pollEnrich`, or `setBody`.
+- Inside `aggregate`, the number of aggregated messages is
`${exchangeProperty.CamelAggregatedSize}`, not `${size}`.
+- The `log` EIP option is `logName`, not `loggerName`. Do not invent option
names — look them up in the catalog.
+- When validation refuses a file, do not guess again: ask the catalog for a
validated sample of the EIP by name and copy its structure.
+
### Schema validation
Always validate generated YAML routes against the [canonical 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).
The [Camel MCP Server](https://camel.apache.org/manual/camel-jbang-mcp.md)
provides validation, component option lookup, and endpoint URI checking — use
it to catch errors before running.
@@ -292,6 +309,7 @@ This is the recommended starting point for all developers,
including those who a
- [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.
- 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 [...]
### CLI Examples
@@ -443,6 +461,8 @@ For high-quality answers about routing, code generation,
and troubleshooting, AI
- **Ask about constraints** — before giving deep advice, ask about message
volume, latency requirements, error tolerance, and target runtime.
- **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.
+- **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
@@ -465,6 +485,7 @@ For high-quality answers about routing, code generation,
and troubleshooting, AI
- [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.
- [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.
- [Trust by Default](https://camel.apache.org/trust/): Why teams trust Apache
Camel in production — release cadence, LTS, security track record,
vendor-neutral governance, bug fix data, dependency maintenance, and AI
readiness.
- [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.
