# What languages are agent skills written in?

> Published 2026-08-25 · https://www.promptzone.com/arlo_liu/what-languages-are-agent-skills-written-in-1d7i

What languages are agent skills written in? A Hacker News thread flagged last week, per [a recent discussion here](https://plicara.ai/research/agent-skill-languages/), highlights a practical, design-level question: when you encode “skills” for autonomous agents, in what languages should you implement them? The thread—11 points and 2 comments—signals a lack of one-size-fits-all answers and a spectrum of tradeoffs tied to ecosystem, latency, and maintainability.

## What It Is / How It Works
Agent skills are pluggable capabilities that an autonomous agent can invoke to perform tasks or fetch data. In practice, teams implement skills as code modules or services that expose a defined interface (for example, a run or execute method) and then register them with an agent framework. The languages you choose shape how you build, test, and extend these capabilities, as well as how you wire skills into prompts, tools, and tool-usage policies. A multi-language approach is common because agent ecosystems tend to bridge AI model calls with runtime tooling via HTTP or inter-language bindings. For example, popular agent frameworks live in both Python and JavaScript ecosystems, enabling easy ties to ML libraries and web-facing tooling. See the ecosystems around languages like Python and JavaScript for concrete patterns (and broader cross-language strategies) at LangChain and beyond [OpenAI function calling](https://platform.openai.com/docs/guides/function-calling) as a language-agnostic integration pattern.

From the discussion, the two overwhelmingly cited ecosystems are the **Python** and **JavaScript/TypeScript** stacks. The thread notes both are central to agent development communities, with Python leaning into AI libraries and rapid prototyping, and JavaScript/TypeScript excelling at web integration and UI glue. The practical takeaway is not which language is “best,” but which workflow you want: Python for experimentation and model-focused tooling, or JS/TS for web app integration and end-user tooling. See the LangChain ecosystem and its language-specific docs for concrete scaffolding in both worlds [LangChain](https://www.langchain.com) and [LangChain Python docs](https://python.langchain.com/docs/modules/agents/) as a reference point.

## Benchmarks / Specs / Numbers
The discussion’s numeric signals are modest but informative. The Hacker News thread collected 11 points and 2 comments, indicating moderate engagement and no clear consensus on a single best language. Observations from participants include:
- Python is the default for many AI practitioners due to its vast ML libraries (transformers, PyTorch, Hugging Face), rapid iteration, and strong data tooling.
- JavaScript/TypeScript is favored for “web-first” agent integrations, where agents live in or alongside front-end UIs or Node-based backends.
- A cross-language pattern—calling external services or microservices—often emerges when teams want to preserve a clean separation between agent reasoning and domain-specific tooling.

| Language ecosystem | Observed pattern (thread) |
|-------------------|---------------------------|
| **Python** | Dominant for AI libraries, rapid prototyping, and data-heavy skills. |
| **JavaScript/TypeScript** | Strong for web integration, UI tooling, and full-stack apps. |

In short, the thread points to pragmatic multipliers: leverage Python where ML work dominates, lean on JavaScript/TypeScript where the agent ships with a web UI or web services, and consider API-bridges when you want language-agnostic tooling.

## How to Try It
Choosing between languages starts with a decision about where your agent will live and how it will be tested. Here’s a concrete path to experiment with both ecosystems.

- Decide on your primary runtime: **Python** for ML-centric skills, or **JavaScript/TypeScript** for web-integrated skills. LangChain provides robust support in both, with documentation at [LangChain](https://www.langchain.com) and language-specific guides at [LangChain Python docs](https://python.langchain.com/docs/modules/agents/) and [LangChainJS docs](https://js.langchain.com/docs/).
- If you’re prototyping with an API-backed agent, leverage OpenAI’s function calling as a language-agnostic bridge. See the [OpenAI function calling docs](https://platform.openai.com/docs/guides/function-calling) for how to expose skills as tools invoked by the model.
- Python setup (quick start):
  - Install: pip install langchain openai
  - Connect to your LLM via API key and define a simple skill module that the agent can call.
- JavaScript/TypeScript setup (quick start):
  - Install: npm i langchain openai
  - Wire a minimal skill into a Node.js or browser-based agent and test prompts that trigger the skill.
- Recommended starter references: the LangChain repo for architectural patterns [GitHub: langchain](https://github.com/hwchase17/langchain) and a broader ecosystem overview [LangChain](https://www.langchain.com). For language-agnostic design, consult community docs and the OpenAI function-calling guide linked above.
- Practical guides and comparisons exist across ML and web tooling sites, including real-world JavaScript vs Python ecosystem discussions **RealPython: Python vs JavaScript**.

Collapsible deep-dive: {% details "How to Try It (step-by-step)" %}
- Pick a skill you can implement quickly (e.g., a weather lookup or a data fetcher).
- Implement the skill in your chosen language, exposing a simple function interface.
- Register the skill with a minimal agent and test via a prompt that calls the skill.
- Validate results, handle errors, and iterate with unit tests that cover both success and failure paths.
- Expand to a multi-skill workflow, then add logging and observability to track calls and outcomes.

{% enddetails %}

## Pros and Cons
- Pros
  - Language choice aligns with team strengths, reducing context-switching costs.
  - Python’s ML ecosystem accelerates model-backed skill development and experimentation.
  - JavaScript/TypeScript ecosystems enable seamless web/UI integration and real-time dashboards.
- Cons
  - Interoperability overhead when mixing languages; you may need API wrappers or IPC mechanisms.
  - Debugging multi-language skill stacks can be trickier, especially across async boundaries.
  - Maintaining consistent data contracts across language boundaries requires discipline (schemas, serialization formats).

Key takeaway: the best path depends on your primary domain (ML-heavy vs web-integrated) and on how you want to scale skill orchestration.

## Alternatives and Comparisons
Two primary axes drive alternatives: the language you use and the integration model. The table below contrasts Python LangChain, JavaScript/TypeScript LangChain, and a language-agnostic OpenAI function-calling approach.

| Feature | Python LangChain | JavaScript/TypeScript LangChain | OpenAI function calling (language-agnostic) |
|---------|-------------------|---------------------------------|--------------------------------------------|
| Primary use-case | AI-model tooling, rapid ML prototyping | Web apps, UI-driven agents | Centralized, API-driven skills regardless of language |
| Ecosystem maturity | Deep ML libraries, notebooks, community tooling | Web tooling, frontend-backend cohesion | Broad language support via API, limited local runtime |
| Development speed (typical) | Fast for ML tasks, quick iterations | Fast for UI-backed workflows | Fast to prototype tools; depends on backend endpoints |
| Interop overhead | Moderate, via wrappers or services | Moderate to high if bridging to ML services | Low; decouples skill logic from model reasoning |

Who should use which? If your core product is ML-powered agents and data science workflows, Python LangChain is the natural fit. If you’re delivering agent-powered tools with a rich web UI or web services, LangChainJS makes integration smoother. If you want language-agnostic, model-driven orchestration with clear separation between reasoning and tooling, OpenAI function calling provides a path that minimizes cross-language friction.

## Who Should Use This
- AI teams building internal tools, research pilots, or data workflows should consider Python-based agent skills first, given the ML library density and rapid prototyping capabilities.
- Teams delivering customer-facing agents embedded in web apps or Node backends should lean toward JavaScript/TypeScript to maximize integration velocity and UI cohesion.
- Organizations prioritizing language-agnostic tooling or rapid interoperability across services should explore OpenAI function calling as the glue between reasoning and execution, regardless of the skill’s native language.

Considerations like team capabilities, existing tech debt, and deployment environment should guide the exact mix of languages and tools you adopt.

## Bottom Line / Verdict
Agent skills can live in multiple languages, with Python and JavaScript/TypeScript at the core of modern practice. The practical choice hinges on your workflow: Python for ML-centric cadence, JavaScript/TypeScript for web and UI alignment, or a language-agnostic API approach for maximal interoperability. The Hacker News discussion on languages highlights that there is no universal winner—only the right tool for the job and the right architecture to support it. As ecosystems evolve, expect more robust cross-language tooling and better multi-language skill orchestration.

Closing thought: staying explicit about data contracts, observability, and testing across skill boundaries will pay off as agent ecosystems scale.

References and further reading (selected external links):
- [Hacker News discussion on agent skill languages](https://plicara.ai/research/agent-skill-languages/)
- [LangChain](https://www.langchain.com)
- [LangChain Python docs](https://python.langchain.com/docs/modules/agents/)
- [LangChainJS docs](https://js.langchain.com/docs/)
- [OpenAI function calling docs](https://platform.openai.com/docs/guides/function-calling)
- [Hugging Face Transformers agent docs](https://huggingface.co/docs/transformers/main_classes/agent)
- [GitHub: LangChain](https://github.com/hwchase17/langchain)
- **Real Python: Python vs JavaScript**

End sign-off: As the landscape for agent skills languages grows, teams should test multi-language stacks against their integration goals to choose the simplest path that delivers reliable, observable agent behavior.