Agent Frameworks Across Languages

What's in this pack

This pack collects the six agent frameworks that let teams stay in their existing language ecosystem instead of bolting a Python service onto a Java or Rust backend just for LLM features. The list spans the four languages where serious agent work is happening outside Python: Java, Rust, TypeScript, and Python (with FastHTML for full-stack rendering).

The pack mirrors the reality that LLM features now ship in every backend, not just Python ones. A Spring Boot e-commerce backend doesn't want to spin up a separate FastAPI service for a chat feature — Spring AI lives in the same JVM. A Rust API gateway doesn't want a Python sidecar — Axum + Candle compile into one binary.

Why language-native matters

The Python-first agent world (LangChain, LangGraph, CrewAI) is great if Python is already your primary stack. If you're a Java shop, you face three bad options without this pack:

1. Run a Python sidecar service (extra deployment, separate observability, marshalling JSON between two processes).
2. Use a SaaS LLM gateway (vendor lock-in, latency, fees).
3. Hand-roll OpenAI HTTP calls inside your Spring controllers (no abstractions, no eval framework, no agent loop).

Spring AI and LangChain4j fix this. They give Java the same primitives — chat models, tool calling, prompt templates, vector stores, agent loops — that LangChain gives Python, with idiomatic Spring or Kotlin DSLs. Same for Rust (Candle for inference, Axum for the API surface) and TypeScript (Mastra for the framework).

The trade-off is feature lag. LangChain ships an integration to a new model on day one; Spring AI takes weeks; LangChain4j sometimes catches up faster than Spring AI because it's community-driven. Plan for "the model launched yesterday and only Python has it" being a real scenario.

Install in one command

# Install the pack — drops a starter project for each framework
tokrepo install pack/agent-frameworks-multilang

# Or pick by language
tokrepo install spring-ai
tokrepo install langchain4j
tokrepo install mastra
tokrepo install candle

The TokRepo CLI handles each ecosystem's package manager — Maven for Spring AI and LangChain4j, Cargo for Candle and Axum, npm/pnpm for Mastra, uv for FastHTML. The starter projects all include a passing test that calls a real model so you can verify your API keys before writing logic.

Common pitfalls

• Spring AI vs LangChain4j is not "official vs unofficial." Spring AI is from VMware/Broadcom; LangChain4j is community. Both are widely used. Choose by feature parity with the model you're using and ergonomic preference (Spring DSL vs LangChain semantics).
• Mastra is young. It's well-maintained but the API has shifted between minor releases. Pin a specific version and read release notes before upgrading. Production users typically wait two minor releases before upgrading.
• Candle is for inference, not orchestration. It runs models locally (Llama, Mistral, etc) and gives you embeddings — but it's not a full agent framework. Pair it with Axum for the API layer if you want a Rust-only stack.
• FastHTML is HTMX-based. It's not a SPA framework. If your team expects React or Vue, FastHTML will feel alien. It's perfect when you want server-rendered Python UIs that wire into agents directly without a separate frontend repo.
• Tool calling formats differ. OpenAI, Anthropic, and Gemini all have different JSON schemas for tool calls. Each framework abstracts this differently — Spring AI's @Tool annotation, LangChain4j's @Tool with reflection, Mastra's typed createTool(). Don't assume a tool definition ports across.

When this pack alone isn't enough

This pack gives you the runtime in your language. You'll still need:

• An LLM provider. OpenAI, Anthropic, Bedrock, or self-hosted via Ollama. All six frameworks support multiple providers via configuration.
• Vector storage if you're doing RAG. See the Vector DB Showdown pack — most entries have native clients in Java, Rust, and TS.
• Eval pipeline. Promptfoo from the LLM Eval & Guardrails pack runs language-agnostic — point it at your endpoint regardless of backend.

For Python-only stacks where multilang isn't the question, see Python Agent Frameworks. For platform-agnostic side-by-side comparison without picking a language, see Multi-Agent Frameworks.