Introduction - HasteKit

HasteKit brings everything you need to ship production-grade AI agents into a single, cohesive platform — from model configuration and tool orchestration to durable workflows, multi-channel deployment, and OpenTelemetry observability. No more stitching together LangSmith, n8n, Temporal, and a half-dozen SaaS dashboards. This guide walks through the platform in the order you’ll naturally consume it: configure a model, build an agent, give it tools and memory, test it, deploy it, and observe it in production.

1. Start with the Agent Builder

The Agent Builder is the heart of HasteKit. Every agent is configured through a dashboard — no code required — across a set of focused tabs covering the model, prompt, tools, memory, and output contract.

Model & Parameters

Pick from 8 providers (OpenAI, Anthropic, Gemini, xAI, Bedrock, OpenRouter, Ollama, ElevenLabs) and tune temperature, top_p, reasoning effort, parallel tool calls, max output tokens, and provider-specific extras like Anthropic cache_control and thinking.

System Prompt

Write a prompt inline, or reference a versioned prompt template with {{variable}} interpolation that’s reusable across agents.

Structured Output

Enforce a JSON schema on agent responses with a schema builder UI (or raw JSON) so downstream code consumes agent output without ad-hoc parsing.

Conversation History

Built-in thread management with configurable summarization strategies to keep context windows — and cost — under control.

2. Give Your Agent Tools

Tools are how agents take action. Every tool — built-in, MCP, OpenAPI, connector, sub-agent, or workflow — has independent Enabled, Requires Approval, and Deferred switches.

Built-in tools

Image, Speech & Transcription

Generate images (xAI grok-imagine, OpenAI gpt-image-1), synthesize speech (ElevenLabs Flash v2.5), and transcribe audio (ElevenLabs scribe_v2) with configurable provider, model, voice, and language.

Web Search & Code Execution

First-class web search and Python/JS code execution — useful tools available out of the box without wiring up MCP servers.

Sandbox

A Docker-backed bash sandbox with configurable image and environment variables for safe, isolated shell execution.

Todo & Schedule

A built-in todo list for progress tracking on long tasks, and a schedule tool that lets agents schedule themselves via cron or one-off triggers.

Bring your own tools

MCP Servers

Attach Streamable HTTP or SSE MCP servers with custom headers, tool filters, approval requirements, and deferred loading.

OpenAPI → Tools

Import any OpenAPI 3.x spec — each operation becomes an agent tool, with HTTP requests handled automatically.

Connector Actions

Expose individual actions from GitHub, Gmail, Google Calendar, Jira, Slack, and Telegram as tools your agent can call directly.

Function Tools & Code

Define custom tools as code when you need full control over execution.

3. Add Memory, Knowledge & Skills

Tools handle doing. The next layer is what your agent knows.

Knowledge Bases (RAG)

Create local knowledge bases with configurable chunking (size, overlap, separators) and embedding provider/model/dimension. Attach any number to an agent for retrieval-augmented answers with citations.

Skills

Author reusable SKILL.md packages of prompts, scripts, and docs in the editor or upload a zip. Pinned skills are mounted at /skills/<name>/ inside the agent’s sandbox.

Long-term Memory

Attach a memory service with Semantic (facts) and Episodic (events over time) memory types. Each service has its own model, prompt, and extraction cadence. The memory_search and memory_add tools are auto-exposed to the agent.

Codebases

Connect GitHub repositories via the GitHub connector. They’re auto-synced and attachable to agents for code-aware reasoning.

4. Compose Multi-Agent Systems

Skip the monolithic prompt. Decompose your agent into focused specialists and have them collaborate.

Agent as a Tool

Invoke a sub-agent as a tool with Isolated or Shared context modes. The parent agent stays in control and aggregates results.

Handoffs

Hand off the conversation mid-flight to a specialist agent. The user keeps chatting; the right agent answers.

Human-in-the-Loop

Flag any tool (built-in, MCP, connector, sub-agent, workflow) as Requires Approval. Sensitive actions wait for a human decision before executing.

Deferred Tools

Load tools on demand instead of all at once. Keep context windows small even with hundreds of tools available.

5. Orchestrate with DAG Workflows

When logic gets complex enough that you want deterministic control flow — not LLM judgment — build a workflow on the visual canvas and expose it to your agent as a tool.

Trigger types — invoked by an agent, cron schedule, or GitHub events (PR opened/updated/closed, issue opened, issue comment, push).
Node types — HTTP Request, AI Agent, Code (JS), and connector actions for GitHub, Gmail, Google Calendar, Jira, Slack, and Telegram.
Control flow — If, Switch, Delay, and End nodes for branching, waiting, and returning structured output.
Runtime — run Local for low latency, or back the workflow with Temporal so every node runs as a durable activity with automatic checkpointing and retries.

Any saved workflow can be called as a tool from any agent — combining the determinism of a DAG with the flexibility of an LLM.

6. Test in the Built-in Chat

Iterate without leaving the dashboard. The chat UI supports per-message agent and version selection, file/image/audio attachments, inline tool-call visualizations, editable context JSON, custom request headers, and one-click jumps to the underlying trace. Debug, iterate, and ship without a separate client.

7. Deploy to Your Users

Once your agent works in the chat, put it in front of users.

Channels

Bind any agent to a Telegram or Slack channel. Each channel gets a unique webhook URL — paste it into Slack Event Subscriptions or your Telegram bot config and you’re live.

Triggers

Auto-invoke agents (or workflows) on a cron schedule, a one-off future time, or a connector event like a new GitHub PR. Status, edit, and delete controls are all visible from the dashboard.

HTTP API

Every agent is also callable via HTTP using a virtual key — drop it into your existing application with a single request.

Versions & Aliases

Every save creates an immutable version. Point a production alias at any version — or split traffic between two versions for canary releases — and roll back instantly when needed.

8. Observe Everything

Every agent run, tool call, and LLM request emits OpenTelemetry traces — complete with token usage, latency, and cost attribution. Drill into a hierarchical span tree: AgentTrigger.HTTP → LoadMessages → GetPrompt → VirtualKeyMiddleware → LLM.StreamingResponses → SaveMessages. Each span shows duration, status, attributes (agent_name, project_id, user_id, org_id), and parent/child links. Aggregate dashboards roll up spans, error rate, average duration, and active services across any time range.

9. Secure & Govern

Virtual Keys

Issue sk-uno-... virtual keys scoped to specific providers, models, and rate limits. Hand out one credential and centrally control access.

Secret Manager & Credentials

Encrypted per-project vault for OAuth client IDs/secrets, bot tokens, and webhooks. Credentials are masked once saved.

Organisation & Roles

Owner and Collaborator roles at the org level, with project-scoped resources for clean separation of work.

Project Export

Export an entire project as a ZIP for portability, backup, or environment promotion.

Next Steps

Build an Agent

Configure your first agent with tools, skills, and structured output.

Documentation Index

​1. Start with the Agent Builder