Model or dataset
wrtnlabs/agentica avatar
wrtnlabs/agentica

Agentica's setup wizard defaults to npm, and its preinstall hook blocks npm

TypeScript AI AI Function Calling Framework enhanced by compiler skills.

1,046 stars65 forksTypeScriptMIT

At a glance

What is it?
A TypeScript framework that turns functions into an agent, accepting a class, an OpenAPI document or an MCP server, with a CLI wizard, a schema normalisation layer between model vendors, and a selector agent that filters candidate functions. Three things do not line up: the wizard's default package manager, the root package's name, and the paragraph that argues the field's direction, which stops mid-word.
Who is it for?
Agentica is worth evaluating if your agent is mostly a bag of functions, because that is the case the framework optimises for and the selector agent is the part that pays off as the function count grows. The marketing promises more than the page shows, so read the four strategies rather than the summary sentence.
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 174 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 October 4, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • wrtnlabs/agentica1,046 ★ · +5
Star history
Repository2026-09-112026-10-04
wrtnlabs/agentica1k1k

5 Stars in the last 23 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The wizard's default selection is the package manager the install hook rejects

The whole install is one command, and it opens an interactive wizard:

bash
$ npx agentica start <directory>

----------------------------------------
 Agentica Setup Wizard
----------------------------------------
? Package Manager (use arrow keys)
  > npm
    pnpm
    yarn (berry is not supported)
? Project Type
    NodeJS Agent Server
  > NestJS Agent Server
    React Client Application
    Standalone Application
? Embedded Controllers (multi-selectable)
    (none)
    Google Calendar
    Google News
  > Github
    Reddit
    Slack
    ...

Three things are visible in that transcript.

The default cursor is on `npm`. Meanwhile the root package blocks npm outright: the preinstall hook is `npx only-allow pnpm`, and the package metadata declares both an engines field requiring pnpm 10 or higher and a package manager pinned to pnpm 10.6.4. So the wizard's first question defaults to the one choice the project refuses.

The second is that the pnpm requirement is enforced three separate ways, one of which is a network call: `only-allow` is fetched through npx on every install, so the check itself can download a package.

The third is the yarn entry, which carries a parenthetical that berry is not supported. That is a constraint stated only inside a wizard prompt, with no version boundary for the yarn line that is supported.

The root package is a private station package while the public entry is @agentica/core

The repository root's package metadata is named `@agentica/station` and is marked private. The public package the badges and the example import point at is `@agentica/core`.

json
  "name": "@agentica/station",
  "version": "0.45.1",
  "private": true,

So the root is a monorepo host rather than a published package, and the name `station` appears nowhere on the page. The version is the useful part: 0.45.1 in the root matches the release tag v0.45.1 from 2026-05-20, which means the root manifest tracks the release line of the packages it hosts.

The release history is regular by recent standards. v0.44.1 on 2026-03-15, v0.45.0 on 2026-04-27 and v0.45.1 on 2026-05-20, with the last push to the default branch dated 2026-05-25, five days after the tag. So the tree is only slightly ahead of the published version, and the versions in the table can be taken at face value.

The structure around it is a genuine pnpm workspace rather than a directory-by-convention monorepo: a `pnpm-workspace.yaml` at the root, a `packages/` directory, and separate scripts that filter into it. Build, publish, lint and test all come in pairs, one for the root and one for the submodules, which is the pattern a workspace needs when each package owns its own toolchain.

Only JSON Schema 2020-12 is emended, and older drafts are upgraded

The architecture diagram is where the framework's actual technique is visible, and it draws two different verbs. JSON Schema v4 through v7 and JSON Schema 2019-03 both point to an emended OpenAPI v3.1 with an arrow labelled upgrades. JSON Schema 2020-12 points to the same target with an arrow labelled emends.

So the pivot is OpenAPI 3.1 treated as an emended form of 2020-12, and the older drafts are converted up into it by a different route. That is the JSON Schema Conversion strategy the page summarises as automatically handling specification differences between LLM vendors, so a function schema is normalised once and the vendor differences are handled downstream rather than per integration.

From that normalised point the diagram runs to AI function calling and then out to five model families, ChatGPT, Gemini, Claude, DeepSeek and Llama, with OpenAI, Google, Anthropic, High-Flyer and Meta named as the organisations.

The diagram does not finish. The last line shown is ChatGPT 3.1 pointing at a node labelled Custom, and the block stops there, so the branch that would cover a custom or self-hosted model is the part a reader cannot see. Combined with the fact that a further edge runs off after it, the diagram is incomplete in a way that matters for anyone whose model is not one of the five named.

Three input protocols, and the two visible constructors do not share a shape

The pitch is that the entire job is listing functions, from one of three sources: a TypeScript class, a Swagger or OpenAPI document, or an MCP server. The page states it plainly, that this is everything you should do for AI agent development, and generalises it further, that anyone who can make functions can make AI agents.

The example shows the first two, and they do not look alike. The class path goes through a typed helper taking a string name and an instance:

`typia.llm.controller<MobileFileSystem>("filesystem", new MobileFileSystem())`

The OpenAPI path goes through an assertion helper taking a configuration object with a name, a model, and a document property. So one is a generic call with a type parameter and an instance, the other is an options object validated at runtime, and the one place the example shows it stops partway through the `docum` property.

That truncation matters because the OpenAPI constructor is the interesting half. A class exposes its own types, so the schema is derivable; a document is untyped input that the framework has to trust, which is what the assertion function is for.

The playground mirrors the split with three demos, a bulletin board example for the class path, an uploader for the OpenAPI path, and an enterprise e-commerce agent, so the demos cover two protocols and one application rather than all three protocols.

The wizard's controller list is a fixed catalog with no free-form entry

The Embedded Controllers step is a multi-select with a hardcoded set: none, Google Calendar, Google News, Github, Reddit, Slack, and an ellipsis. The transcript ends there.

For a framework whose central claim is that you bring your own functions, the setup path offers no way to name a function or a controller of your own. Everything you can select at this step is a controller the CLI already knows about, and the ellipsis means even the full list is not shown in the prompt.

The default cursor is on `Github`, meaning a user pressing enter through the wizard ends up with a GitHub controller they did not ask for. That is a reasonable default for a first project and an annoying one for anyone who wanted an empty scaffold.

The practical read is that the wizard optimises for the first thirty seconds and gets out of the way only for the project template. A controller it does not list has to be added after generation, which means the wizard is a convenience rather than a constraint, and the documentation points to a Getting Started guide for the rest.

Three of the four project types switch on a WebSocket server

The project type choice has four options: NodeJS Agent Server, NestJS Agent Server, React Client Application and Standalone Application. The note under the transcript says that any option other than Standalone Application will implement the WebSocket Protocol for client-server communication.

So one flag decides whether your process serves a socket or not, and three of the four paths do. That has consequences the wizard does not spell out. A React client application implies a separate front end talking to the agent over that socket, the NestJS option implies a server framework around it, and the NodeJS option is the plain case. Standalone is the exception, and it is the one where the framework runs as a single process with no network protocol.

The WebSocket protocol has its own documentation section, which makes it a first-class part of the contract rather than an implementation detail, and it is one of five links under Core Library in the documentation index, alongside the concepts pages for function calling and compiler-driven development.

It also means the architecture is not swappable after the fact without regenerating: a Standalone project and a NestJS project have different process shapes, and the choice is made before any code is written.

The release script copies the README into packages, and the published files include src

The release pipeline is short and it does something to the readme:

json
    "release": "node deploy/sync_readme.js && bumpp",
    "sync-readme": "node deploy/sync_readme.js",

A script in the `deploy/` directory rewrites the readme, and the version bump runs after it. So the readme you read on the repository is a source, and the one inside each published package is generated from it. That is why the root page can carry badges for `@agentica/core` while the root package is the private `@agentica/station`.

Publishing comes in two channels. `package:latest` publishes the packages with the latest tag, and `package:next` runs a shell script called `next.bash` from the root, so there is a prerelease channel with its own script. The version itself is handled by `bumpp` with a `bump.config.ts` at the root.

The published file list is the entry worth a look:

json
  "files": [
    "LICENSE",
    "README.md",
    "lib",
    "package.json",
    "prompts",
    "src"
  ],

Both `lib` and `src` ship, which for a framework built on compiler skills is defensible since the source is the documentation. A `prompts` directory also ships and is never mentioned on the page, and nothing in the visible text explains whether those prompt files are a supported extension point or an internal detail.

The paragraph arguing the field's direction stops mid-word

The page opens its argument for why function calling matters with a piece of industry history, and it is worth reading closely because of how it ends.

It says that in 2023, when OpenAI announced function calling, many predicted that function calling-driven development would become the mainstream. Then the counterpoint: in reality, because of the difficulty and instability of function calling, the trend in AI development became agent workflow. And then the sentence stops partway through describing what agent workflow is, at the words Agent workflow, which is inflexible and must be cre.

So the passage that would state the thesis stops in the middle of a word. The claim being set up is that workflows are inflexible and must be created, and the argument for why function calling is the better primitive never appears.

The rest of the page is unaffected by that. Four strategies are listed with links to their own documentation pages: compiler-driven development that builds function calling schemas automatically through compiler skills without hand-writing, JSON schema conversion, validation feedback that detects and corrects argument composition mistakes, and a selector agent that filters candidate functions to reduce context usage and token consumption. The selector is the one with a clear cost story attached, since function count is the variable it optimises.

Two other things about the page's surface. It links a newsletter, a Discord server, a YouTube channel and a Bloomberg video about the company's funding, and it leaves an HTML comment in the playground section reading that the section would be changed after making a tutorial playground.

Editorial conclusion

Agentica is worth evaluating if your agent is mostly a bag of functions, because that is the case the framework optimises for and the selector agent is the part that pays off as the function count grows. The marketing promises more than the page shows, so read the four strategies rather than the summary sentence. Two things to check before you commit. The compiler-driven path is the one that distinguishes this framework, and the page describes it in a single line, so find out what the compiler skills actually do to your types before you rely on them. And treat the vendor compatibility claim carefully, since the whole schema layer exists to paper over differences between providers, which means a model vendor change lands on that layer rather than on your code. The setup wizard is convenient but fixed, so a controller it does not list has to be added afterwards by hand.

Frequently asked questions

What package manager does agentica require?

pnpm 10 or higher. The preinstall hook is `npx only-allow pnpm`, the engines field requires pnpm 10 or newer, and the package manager is pinned to pnpm 10.6.4. The setup wizard offers npm, pnpm and yarn, with a note that yarn berry is not supported, and its cursor starts on npm.

How do I create a new agentica project?

Run `npx agentica start <directory>`. The wizard asks for a package manager, a project type, and embedded controllers. Any project type other than Standalone Application implements the WebSocket Protocol for client-server communication.

What are the three input protocols agentica accepts?

A TypeScript class, a Swagger or OpenAPI document, and an MCP server. The class path goes through a typed controller helper taking a name and an instance, and the OpenAPI path goes through an assertion helper taking a name, a model and a document object.

Can I use a model that agentica does not name?

The architecture diagram normalises schemas into an emended OpenAPI v3.1 and then branches to ChatGPT, Gemini, Claude, DeepSeek and Llama. The diagram's last visible edge runs from ChatGPT 3.1 to a node labelled Custom, and that branch is cut off, so the page does not show how a custom model is handled.

What does the agentica selector agent do?

It filters candidate functions to minimise context usage, optimise performance and reduce token consumption. It is one of four strategies on the page, alongside compiler-driven development, JSON schema conversion, and validation feedback that corrects argument composition mistakes.

Where is the agentica README generated from?

The release script runs `node deploy/sync_readme.js && bumpp`, and a separate sync-readme script runs the same file. The readme inside each published package is therefore generated at release time, and the root page is the source.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. wrtnlabs/agentica on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/wrtnlabs-agentica.svg)](https://hysenlabs.com/projects/wrtnlabs-agentica)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/wrtnlabs-agentica.svg)](https://hysenlabs.com/projects/wrtnlabs-agentica)

Was this useful?