Lamatic AgentKit: a registry of deployable agent apps, not an agent framework
Ready to Deploy Fullstack OpenSource Agentic Apps
At a glance
- What is it?
- AgentKit is a flat kits/ directory of 70 agent templates, bundles and full Next.js apps built on Lamatic workflows. It is a starting-point catalogue, and the README documents the catalogue better than it documents the runtime.
- Who is it for?
- Adopt AgentKit if you want a working Next.js front end in front of a Lamatic flow and you are willing to read the code rather than the README, because the registry and lamatic.config.ts files carry the detail. Do not adopt it if you want a framework to build an agent loop from scratch, or if you need to run entirely offline: every kit depends on Lamatic-hosted flows.
- 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 10 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 18, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What AgentKit actually ships: a registry, not an SDK
The name suggests a library you import. The repository layout says otherwise. The top level holds kits/, registry.json, public/, highlights.json and a scripts directory referenced from the README, with no src/ or packages/ monorepo structure. Everything lives in a flat kits/ directory, and the README states that each entry is a template (single flow), a bundle (multi-flow, no UI), or a kit (flows plus a runnable Next.js app), distinguished by the type field in its lamatic.config.ts.
The README's auto-generated table counts 70 entries: 22 kits, 6 bundles, 42 templates. That ratio is the honest description of the project. Most of the repository is flow definitions, not applications. The 22 kits are the part most people will actually run, and they are Next.js apps wired to Lamatic workflows: support triage, code review, deep research, embedded chat and search, blog automation, a career copilot, a startup research agent.
So the audience is narrow and specific. It is for someone who has a Lamatic account, wants a customer-facing interface for a flow, and would rather fork a working app than assemble one. It is not for someone who wants to write an agent loop.
How a kit is wired: config file, flows, Next.js app
The mechanism visible in the repository is configuration-driven. A kit directory contains a lamatic.config.ts whose type field declares whether the entry is a template, bundle or kit, plus the flow definitions that the Lamatic platform executes. Kits add a Next.js application on top.
That means the agent logic does not live in the repository as TypeScript you can read line by line. The repository holds the declaration of which flows exist and the front end that calls them. The reasoning steps, model selection and tool calls are configured in Lamatic Studio and executed by Lamatic's serverless deployment, which the README markets alongside the SDK and the studio.
The registry.json file is the machine-readable index of all of this. The README states the kits table is auto-generated from registry.json by scripts/update-readme.mjs, and carries the instruction not to edit it by hand. That is a small but real design decision: the catalogue is data, the README is a rendering of it, and a contribution that adds a kit is expected to touch the registry rather than the prose.
The practical consequence is that a kit is portable only as far as the Lamatic platform is portable. You get the UI and the flow graph; you do not get a self-contained agent binary.
Installing and running your first kit
The README does not contain a repository-wide install section. It points at individual kit directories, and the kits are Next.js apps, so the flow is the one you would expect from that stack. Start by cloning the repository and moving into one of the listed kits, for example the deep research kit that has a live demo at agent-kit-reasoning.vercel.app.
git clone https://github.com/Lamatic/AgentKit.git
cd AgentKit/kits/deep-searchFrom there the app is a Node project. The README does not document the exact package manager or script names for this kit, so check the package.json inside the kit directory before running anything; a Next.js app of this shape normally exposes dev, build and start scripts.
npm install
npm run devWhat you should see is the kit's Next.js interface served locally. What you will also need is configuration the README does not spell out at the root level: a Lamatic project with the flows this kit references, and whatever API credentials the app reads at runtime. Look for an environment file in the kit directory and copy it before starting the dev server, because a kit whose flows are not deployed in your account will render but fail on submit.
The exact variable names are kit-specific and the README does not list them, so read the environment file rather than guessing. This is the first real friction point of the project: the repository tells you what exists, and the kit tells you how to run it, but the two are not joined by a single getting-started document.
The Lamatic dependency is the whole architecture
Every kit in the registry is described as flows plus a runnable Next.js app. The flows are Lamatic flows. Nothing in the repository suggests a kit can execute its reasoning without the Lamatic platform, and the README's own framing places the SDK, the collaborative studio and serverless deployment as three parts of one stack.
That is a deliberate trade and it cuts both ways. In exchange for a hosted control plane, you get kits that are genuinely short: a config file, a flow definition and a front end, rather than a few thousand lines of orchestration code. The cost is that the interesting part of the system is not in the repository. If you want to audit how the code review kit decides what counts as a security vulnerability, you will be reading a flow graph in a studio, not a diff in Git.
It also means the project's portability story is thin. A team that needs to run inference against a self-hosted model, or that has procurement rules against sending source code through a third-party control plane, cannot simply point AgentKit at a local endpoint. The kits would still be readable, and the Next.js front ends would still be reusable, but the agent behaviour would have to be rebuilt elsewhere. Treat AgentKit as a front-end and configuration catalogue for one platform, not as a vendor-neutral toolkit.
Where AgentKit is the wrong choice
Three cases stand out.
First, if you are evaluating agent frameworks, this is not one. There is no loop abstraction, no tool-calling runtime and no memory layer exposed as code in the repository. Comparing it to a framework will produce a confusing result, because they solve different problems: one gives you primitives, the other gives you finished apps.
Second, if you need a documented upgrade path, the repository does not provide one. No releases were retrieved, and the README does not describe versioning, migration or rollback for kits. The last push to the repository was on 2026-09-08, so the code is current, but currency is not the same as a compatibility policy. A kit you fork today has no stated contract about what changes under it.
Third, if your team has no Lamatic account and no intention of creating one, the 22 kits reduce to reference implementations of Next.js interfaces. That is still worth something, but it is a fraction of what the README's framing implies. The bundles and templates, which are 48 of the 70 entries, are even more platform-bound: they are flow definitions with no UI at all.
The realistic alternative: build the loop yourself
The obvious comparison is a code-first agent framework, where you define tools, a model call and a control loop in your own repository and deploy it wherever you like. The difference is not quality, it is where the complexity sits.
With a framework, you own the orchestration code and the hosting, and you start from an empty file. With AgentKit, you own a Next.js app and a set of flow definitions, and you start from something that already has a support triage screen or a deep research interface. The framework gives you control over every model call; AgentKit gives you a working product surface in exchange for that control.
A second alternative is simply building the front end yourself against the Lamatic SDK. That is the honest middle path for teams that like the platform but not the kits: the README lists the SDK as one of the three components of the stack, so the kits are one consumer of it rather than the only way in. If a kit's UI does not match your product, the SDK is the layer underneath it.
What AgentKit genuinely offers that neither alternative does is the registry itself: 70 entries with authors, descriptions and, for several kits, live demo links. That is a browsing surface for ideas, and it is cheap to use even if you never deploy a single kit.
Licence, contributions and what maintenance looks like
The repository is MIT licensed, which is permissive and places few conditions on reuse of the code in the repository. The practical caveat is scope: the licence covers what is in the repository, and the Lamatic platform that the kits call is a separate service governed by its own terms. Reusing a kit's Next.js code and running its flows are two different acts, and only the first is settled by the MIT grant. That is a factual boundary, not legal advice; check the platform terms for the second.
On maintenance, the facts are limited. The repository is not archived, and the last push was on 2026-09-08, which is recent. There are no retrieved releases, so there is no changelog to read and no version tags to pin against. The README routes contribution questions to GitHub Discussions rather than Slack, on the grounds that answers stay searchable, and it points contributors at issues for bugs and a separate discussion category for ideas. The topics list includes good-first-issue and hacktoberfest, and CHALLENGE.md and CLAUDE.md sit at the top level, which suggests the project actively recruits outside contributions to the kits directory.
For an adopter, the upgrade cost is therefore unknown rather than high. You can pin a fork, but the repository gives you no signal about how often kit internals change or whether a kit's flow contract is stable across platform updates.
Editorial conclusion
Adopt AgentKit if you want a working Next.js front end in front of a Lamatic flow and you are willing to read the code rather than the README, because the registry and lamatic.config.ts files carry the detail. Do not adopt it if you want a framework to build an agent loop from scratch, or if you need to run entirely offline: every kit depends on Lamatic-hosted flows. Before committing, open kits/deep-search, read its lamatic.config.ts and its environment file, and confirm that the flow IDs and model providers match what your Lamatic account can deploy. If your account cannot create a matching flow, the kit is a UI shell and nothing more.
Frequently asked questions
What is AgentKit?
AgentKit is a repository of ready-to-deploy agentic apps built on Lamatic. The README describes a flat kits/ directory of 70 entries: 22 kits with runnable Next.js apps, 6 bundles with multiple flows and no UI, and 42 single-flow templates.
How do I install AgentKit?
There is no repository-wide installer. You clone the repository, move into one kit directory such as kits/deep-search, and run it as a Next.js app with npm install and npm run dev. The README does not document the per-kit script names, so check the kit's package.json.
How do I use AgentKit?
Pick an entry from the registry, read its lamatic.config.ts to see whether it is a template, bundle or kit, and for a kit copy the environment file and start the Next.js app. The flows the kit references must exist in your Lamatic account, otherwise the interface loads but its actions fail.
How do I access AgentKit?
The code is public on GitHub under the Lamatic organisation, and the README links a homepage at git.new/agentkit plus the Lamatic website and docs. No sign-up or invite is described for reading the repository; running a kit's flows requires a Lamatic account.
Community notes