Typed interface
Each tool exposes named methods. The shape is inspectable before the model calls it.
For Developers
Trust developers to make AI useful.
Kazibee lets developers add deterministic TypeScript tool calls to the models teams already use. AI adapts to intent, timing, and context. Your code defines exactly what happens.
aws-logs/src/index.ts Typed tool
export default function main() {
return {
countErrorsByMinute(input: {
service: 'checkout' | 'billing' | 'api';
windowMinutes: 15 | 30 | 60;
bucketMinutes: 1 | 5;
}) {
// Fixed log groups, redaction, and time limits.
return cloudWatch.countErrors(input);
}
};
}
The model can call countErrorsByMinute.
It gets structured counts for a chart, not open-ended AWS access.
The platform bet
Useful platforms are improved by the developers solving real problems.
A platform cannot predict every workflow, internal API, data source, or edge case. Developers can. Kazibee is extensible because the best AI capabilities will come from people building against their own constraints.
Real systems
Connect models to the APIs, databases, queues, files, and services your work already depends on.
Real constraints
Keep validation, permissions, formatting, and business rules in code you can review and test.
Real leverage
Add capabilities to the models your team already uses instead of rebuilding the whole AI stack.
AI adapts. Code guarantees.
Let the model choose the moment. Let TypeScript do the work.
AI is valuable because it can understand intent, gather the right data, and decide when a tool is useful. Deterministic code is valuable because it runs the same way every time. Kazibee connects those strengths through typed contracts.
Example flow
User asks
Checkout started failing for some users. Look at the last hour of production logs and tell me what changed.
AI adapts
Maps checkout to the right service, chooses a safe time window, then asks for error counts by minute.
Code guarantees
The AWS plugin controls log access. The chart tool turns the returned counts into a repeatable interface.
const series = await tools["aws-logs"].countErrorsByMinute({
service: "checkout",
windowMinutes: 60, bucketMinutes: 5
});
return await tools["chartjs"].lineChart({
title: "Checkout errors, last hour",
labels: series.labels, values: series.counts
});
Chart.js output
errors / 5 minBounded by design
Extensible does not mean uncontrolled.
Plugins are locked to the contracts developers provide. The model sees callable methods with declared inputs and outputs, not arbitrary access to the machine.
Bounded access
If a capability is not on the approved interface, it is not available to the model.
Reviewable behavior
The risky parts stay in normal TypeScript: versioned, tested, reviewed, and owned by developers.
The developer loop
The contract is visible before anything runs.
Kazibee's CLI is built around understanding first. Link or install a plugin, inspect its TypeScript interface, read its usage notes, then execute only against the tools that were exposed.
terminal
# 1. Add a local TypeScript plugin during development
kazibee link aws-logs ./aws-logs
# 2. Inspect the exact interface the model can call
kazibee show aws-logs
# 3. Read tool-specific instructions before using it
kazibee llm aws-logs
# 4. Execute against the approved tool surface
echo 'return await tools["aws-logs"].countErrorsByMinute(input)' | kazibee exec
Plugins can also expose their own setup commands, like kazibee gmail login, while model-facing calls stay inside tools["plugin"].method(...).
From question to interface
Ask for a trend. Get a real chart.
A model can turn “are production bugs getting worse?” into the right query. The issue plugin returns counts. The Chart.js plugin renders the result as an interface people can read.
1
AI chooses the query
It maps “production bugs” to the tracker label, date range, and weekly grouping.
2
TypeScript returns counts
The plugin controls which tracker, fields, labels, and date windows can be queried.
3
Chart.js renders the answer
The chart is deterministic output from structured data, not a generated drawing.
Production bugs by week
User asks
Are production bugs getting better or worse this quarter?
const issues = await tools["issue-metrics"].countIssues({
label: "production",
groupBy: "week", range: "quarter"
});
return await tools["chartjs"].barChart(issues);
Production bugs opened
Grouped weekly from issue tracker results
18
27
22
36
31
21
16
24
W1W2W3W4W5W6W7W8
How it works
A small TypeScript surface. A big capability jump.
1
Write the tool
Use TypeScript to implement the deterministic behavior: query a system, render a chart, validate data, update a record, or run a workflow.
2
Expose the contract
Kazibee discovers the methods and gives the model the interface you approved. The contract is the boundary.
3
Let AI route the work
The model reads the request, decides when the tool is useful, passes structured input, and uses the result in the conversation.
Built into the workspace
Extensions meet the models you already use every day.
Kazibee still gives developers the workspace basics: named threads, worktrees, project context, and model switching. Plugins add the missing piece: your own capabilities inside those same conversations.
Threads
Keep context organized around real work.
Worktrees
Bind AI context to the branch you are editing.
Models
Use Claude, Codex, Gemini, and more against the same tools.
Give AI reliable capabilities.
Build deterministic TypeScript tools, expose only the contract you trust, and let adaptive models call them at the right moment.
Free desktop app. Bring your own keys. Plugins are bounded by the interfaces you define.