Quick Start
Build a working plugin in 5 minutes. From an empty folder to a tested tool.
What you are building
A Kazibee plugin is a TypeScript module that exposes methods to AI agents. When an agent needs to interact with an external service — check a calendar, send a message, query a database — it calls your plugin's methods as tools.
In this guide, you will create a simple plugin, link it for local development, and test it. By the end, you will have a working plugin that an AI agent can call.
What you need
A minimum viable plugin requires just two files: a package.json that tells Kazibee about your plugin, and a src/index.ts that exports the methods. That is it. No build step, no configuration files, no dependencies.
Step 1 — Create your project and package.json
Create a new directory for your plugin and add a package.json. Every field here matters:
{
"name": "my-plugin",
"type": "module",
"main": "./src/index.ts"
}
"name" — Your plugin's package name. Can be anything you like.
"type" — Must be "module". Kazibee uses ES modules. Without this, imports will fail.
"main" — Points to your entry file. This is where Kazibee looks for your main() function.
Step 2 — Write your entry point
Create src/index.ts. Your plugin must export a default function called main that returns an object. Each property on that object becomes a method (tool) that AI agents can call.
export default function main() {
return {
hello: async (name: string) => {
return `Hello, ${name}!`;
},
add: async (a: number, b: number) => {
return a + b;
}
};
}
That is your entire plugin. The hello method takes a name and returns a greeting. The add method takes two numbers and returns their sum. When an AI agent calls tools["my-plugin"].hello("world"), it gets back "Hello, world!".
Step 3 — Link it for local development
Now tell Kazibee where your plugin code lives. The link command creates a symlink from Kazibee's internal registry to your local directory. This is for development — every time you edit your code, Kazibee picks up the changes automatically.
(For production, you would use kazibee install to clone from GitHub. But during development, link is what you want.)
dev@local:~/workspace $ kazibee link my-plugin ./my-plugin
The first argument (my-plugin) is the name you are registering. The second (./my-plugin) is the path to your plugin directory.
Step 4 — Verify it loaded
Run kazibee show to confirm Kazibee loaded your plugin and can see its methods. This reads your entry point, calls main(), and prints the methods it found.
dev@local:~/workspace $ kazibee show my-plugin
# You should see your methods listed:
hello(name: string) => Promise<string>
add(a: number, b: number) => Promise<number>
If you see your methods with their types, everything is working. If not, check the Development Workflow troubleshooting section.
Step 5 — Test it
Use kazibee exec to run your plugin's methods in the same sandbox environment that AI agents use. Pipe in a JavaScript expression and see the result.
dev@local:~/workspace $ echo 'return await tools["my-plugin"].hello("world")' | kazibee exec
"Hello, world!"
dev@local:~/workspace $ echo 'return await tools["my-plugin"].add(2, 3)' | kazibee exec
5
Your plugin is working. An AI agent can now call these methods as tools.
Need API keys or credentials?
If your plugin connects to an external service, you will need to declare environment variables and set up authentication. See the Authentication page for the full walkthrough — it covers API keys, OAuth2, and how credentials flow through the sandbox.
What to read next
Plugin Structure — Understand the full file layout: index.ts, command.ts, permissions.json, and llm.txt
Entry Point — Deep dive into the main(env) function, return types, and how Kazibee discovers your methods
Development Workflow — The full dev loop with every command explained, plus troubleshooting tips
Authentication — Set up API keys, OAuth2, and credential management for your plugin