Agentica: Turning TypeScript Classes, Swagger Documents and MCP Servers into LLM Function Calls
TypeScript AI AI Function Calling Framework enhanced by compiler skills.
At a glance
- What is it?
- Agentica is an MIT-licensed TypeScript framework that converts three kinds of function sources into tool definitions for OpenAI, Gemini, Claude, DeepSeek and Llama models. It is a good fit if your tools already exist as typed code or an OpenAPI document, and a poor fit if you need a language-agnostic runtime or a stable API surface.
- Who is it for?
- Adopt Agentica if your tools already exist as typed TypeScript classes, an OpenAPI document or an MCP server, and you want them exposed to a model without writing tool schemas by hand. Skip it if you need a non-TypeScript runtime, a frozen API surface, or a framework that hides provider-specific JSON Schema differences from you.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 114 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem Agentica targets: tool schemas written by hand
Function calling requires the model to receive a machine-readable description of every tool it may call: name, parameters, types, required fields. Writing that by hand for a large API is tedious and drifts out of sync with the implementation. Agentica's stated position is that you should not write it at all. The README puts it plainly: list functions from three protocols (TypeScript Class, Swagger/OpenAPI Document, MCP Server) and that is everything you should do for AI agent development. The pitch to a specific audience is explicit as well: are you a TypeScript developer? Then you're already an AI developer. That framing tells you who the project is for. It is for backend engineers who already own typed service code or an OpenAPI spec and want an agent on top of it, not for teams building a model-agnostic orchestration layer from scratch in another language.
How the controllers array becomes the model's tool list
The core object is Agentica, constructed with a vendor block and a controllers array. The vendor block carries an SDK client and a model string, for example new OpenAI({ apiKey: "********" }) with model "gpt-4o-mini". Each controller is a function source. A TypeScript class is wrapped with typia.llm.controller<MobileFileSystem>("filesystem", new MobileFileSystem()), which means the type information on the class is what produces the callable surface. An HTTP API is wrapped with assertHttpController, which takes a name, a model, a Swagger document fetched at runtime, and a connection object holding the host and headers. The README's example fetches https://shopping-be.wrtn.ai/editor/swagger.json and sets an Authorization bearer header. Once constructed, the entry point is a single call: await agent.conversate("I wanna buy MacBook Pro"). So the data flow is: source (class type, OpenAPI document, or MCP server) to controller to tool definitions to model to function execution. The README's diagram adds a detail worth noticing. It shows JSON Schema v4 through v7, 2019-03 and 2020-12 being emended into what it calls OpenAPI v3.1 (emended), and then shows providers splitting: ChatGPT and Gemini land on custom JSON Schema, while Claude, DeepSeek and Llama land on standard JSON Schema. That is the project admitting that provider schema handling is not uniform, which is the kind of detail that usually gets buried.
Setup wizard, project types and the WebSocket default
Installation starts with npx agentica start <directory>, which launches an interactive wizard. It asks for a package manager (npm, pnpm, or yarn, with berry explicitly unsupported), a project type (NodeJS Agent Server, NestJS Agent Server, React Client Application, or Standalone Application), and embedded controllers chosen from a multi-select list that the README shows as including Google Calendar, Google News, Github, Reddit and Slack. One behavioural detail matters more than the menu: any project type other than Standalone Application implements the WebSocket Protocol for client-server communication. If you pick React Client Application expecting an in-browser agent, you are actually getting a client that talks to a server over WebSocket. The README points to a separate WebSocket Protocol page for that. There is also a hosted playground with three demos (a TypeScript class example, an OpenAPI uploader, and an enterprise e-commerce agent) that you can open before installing anything. The README does not document configuration keys beyond the constructor fields shown in the code sample, so treat vendor.api, vendor.model, controllers, and the assertHttpController connection object as the surface you can rely on from this material alone.
Where the abstraction leaks: provider schema differences and version churn
The README's own diagram is the strongest argument against treating Agentica as a uniform layer. ChatGPT and Gemini are shown receiving custom JSON Schema while Claude, DeepSeek and Llama receive standard JSON Schema. Whatever Agentica does internally to bridge that, the fact that the project draws the distinction means the output is not identical across vendors. A tool that behaves correctly on one model may not on another. The second limitation is version velocity. Releases listed are v0.45.1 on 2026-05-20, v0.45.0 on 2026-04-27, and v0.44.1 on 2026-03-15. That is roughly a minor release per month, and the project is still in the 0.x range, where semver permits breaking changes in minor versions. Nothing in the supplied material promises API stability. The third gap is documentation depth. The README routes almost everything to wrtnlabs.io, and the constructor options beyond the sample are not enumerated here. If you need to know how errors from a failing tool call surface, or how the agent decides between two controllers with overlapping function names, this material does not say. That is not a defect claim, it is a statement about what can be verified from the repository README alone.
The alternative worth comparing: hand-written JSON tool schemas
The obvious alternative is calling the provider SDK directly and passing a tools array you author yourself. The difference is not convenience, it is where the work happens. With a hand-written schema you control exactly what the model sees: you can trim a 200-endpoint OpenAPI document down to the six operations that matter, rename parameters for clarity, and pin the JSON Schema dialect to whatever your provider accepts. Agentica inverts that. You hand it the source and it derives the surface, which is faster when the source is already good and riskier when it is not. A sprawling Swagger document becomes a sprawling tool list, and every operation you never wanted the model to call is now a candidate. The README's e-commerce example pulls a full swagger.json from a shopping backend, which is exactly the case where you would want to check what got exposed. So the trade is derivation speed against curation control, and the right answer depends on whether your existing API surface is already close to the surface you want the model to see.
Licence and what maintenance actually costs you
Agentica is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive licence with no copyleft obligation on your own code. This is not legal advice, and if you are shipping in a regulated context you should have counsel confirm how MIT interacts with your dependency policy and any bundled third-party SDKs. The practical maintenance cost is the release cadence. Three releases in roughly two months, all in the 0.x line, means you should expect to read changelogs before bumping, and you should expect the constructor options and controller helpers to move. If your team pins dependencies and upgrades quarterly, that is manageable. If you upgrade on every release without reading notes, a 0.x project publishing monthly is a poor fit. There is also no stated long-term support policy in the supplied material, so plan for the possibility that a helper you depend on is renamed between minors.
Who should adopt Agentica, and who should walk away
Adopt it if you are a TypeScript team with existing typed service classes or an OpenAPI document and you want those exposed to a model without authoring tool schemas. The typia.llm.controller path in particular means your class types are the contract, so the tool definitions track your code rather than a separate file. Adopt it if you want the WebSocket server scaffold, since the wizard generates NodeJS or NestJS agent servers with that transport already wired. Walk away if you need a runtime outside TypeScript, if your tool surface must be hand-curated down from a large API, or if you cannot absorb monthly 0.x releases. Before committing, do three things: open the playground demos to see actual behaviour rather than the README's framing, read the WebSocket Protocol page if you chose any project type other than Standalone Application, and check the JSON Schema compatibility diagram against the specific model you intend to use, because the README shows ChatGPT and Gemini on custom JSON Schema and the others on standard. Verify that split against your provider before you build on top of it.
Editorial conclusion
Adopt Agentica if your tools already exist as typed TypeScript classes, an OpenAPI document or an MCP server, and you want them exposed to a model without writing tool schemas by hand. Skip it if you need a non-TypeScript runtime, a frozen API surface, or a framework that hides provider-specific JSON Schema differences from you. Before wiring it into anything that handles money or user data, read the JSON Schema compatibility diagram in the README and confirm which schema version your chosen provider actually accepts, because the README shows ChatGPT and Gemini landing on custom JSON Schema while Claude, DeepSeek and Llama follow the standard. Then check the release cadence against your upgrade tolerance.
Community notes