Workflows
For repeatable jobs: author and validate a UWS package, confirm its steps, then approve the exact package separately.
Technology
AI helps draft. You approve. An engine follows the workflow.
Kinet routes requests to workflows, chat or projects. OpenUdon authors and validates UWS and Udon executes it, inside rootless Podman workers that hold no authority.
Three routes for different work
Kinet routes each request and shows you which route it chose.
Chat
For simple questions: a direct model reply, with the turn recorded in audit metadata.
Projects
For larger goals: an interview becomes milestones and tasks. Confirm the proposal and carry out the external actions yourself.
Tech stack
Built to keep authority away from the code that runs
Kinet is a Go service. Agents keep their own state; the code that runs a job is disposable and holds no authority.
One service, plain storage
A Go application with pure-Go SQLite for app and audit records, a React and TypeScript browser app embedded in it, and a Markdown and Git ledger for every agent.
Rootless Podman workers
Jobs run in rootless Podman from one exact, immutable OCI image. Kinet alone talks to the engine, nothing is pulled at run time, and each job's container is removed when it ends.
A tightly bounded sandbox
The worker has no network of its own, a read-only root, dropped capabilities, no-new-privileges, and fixed limits on processes, memory, CPU, output and lifetime. Only fixed commands run. Calls to the APIs you approved, such as a weather service, are sent by Kinet's broker, not by the worker.
Authority stays on the host
Credentials, approvals and the audit record belong to Kinet's host process. A broker sends only the HTTPS requests you approved, and an audit failure cannot change an outcome.
Open workflow standards
UWS describes the workflow, OpenUdon authors and validates it, Udon executes it and APItools prepares API sources. Your API descriptions supply the operations.
Operations
A dedicated unprivileged systemd service, host disk encryption and encrypted Restic backups.
Roadmap (tentative): sealed configuration. Operator secrets would stay encrypted at rest and be released only when a threshold of operators supply key shares, using Shamir secret sharing, so a stolen disk image or backup holds only ciphertext.
Design principles
Agents persist. Compute is disposable. Work is visible.
Each agent keeps its own workspace, ledger and history, while the container that does a job comes and goes without taking that history with it.
Chat, project goals, activity and approvals are always in view, with one decision inbox across your agents and a record of what you asked, approved and observed.
Roadmap (tentative): stronger isolation tiers for hosting at scale, such as gVisor-class sandboxes or a virtual machine per user. These are directions we are evaluating, not features today.
What this buys you
- The code that runs a job holds no credentials and reaches the network only through Kinet's broker
- Every run is bound to an approval you gave for that exact package
- Uncertain writes are recorded as unknown, never retried automatically
- An audit record that observes what happened and never changes it
Project plans
Confirm the proposal before it becomes your plan
Kinet interviews you about the outcome and proposes milestones and tasks. Confirm writes that exact proposal; reject revises it and writes nothing.
An interrupted interview can be listed, resumed at its current question or abandoned without publishing.
Roadmap (tentative): turn a stabilized project process into a workflow. That conversion is a proposed bridge, not an automatic feature today.
The boundary on action
Bookings, purchases, messages and other external actions remain tasks for you.
Workflow authoring
Review each step, then approve the exact package
- Draft. Kinet proposes the outcome and outline, with model assistance.
- Confirm steps. Each step is confirmed before the next is built.
- Validate. The package must pass validation; unresolved placeholders block assembly and approval.
- Approve. Review each destination and request rule. Confirm a single-use grant for one run, or separately approve a bounded recurring schedule.
- Run. The approved package runs in an isolated runner. Calls go only to the APIs you approved.
Who does what
The model drafts and proposes field mappings and repairs. It is told not to choose API operations, endpoints or credentials. You confirm or reject each proposal.
OpenUdon owns UWS authoring and validation. The qualified local path hands the approved package to Udon. Kinet excludes provider credentials from its workflow subprocess profiles.
Open specification
UWS builds on existing API descriptions
UWS, the Udon Workflow Specification, is an overlay on OpenAPI, AsyncAPI and GraphQL descriptions. The API description owns the operations; UWS adds workflow structure, request values, outputs and control flow.
Published foundations
- Apache 2.0 licence
- Versioned JSON Schemas and a Go validator, including version 1.12.0
- Read, write and unknown operation effects, with non-executable pending steps
- Portable execution semantics and executable conformance vectors
- Extension profiles for operations outside an API description, including browser automation and sign-in
Browser capture and external browser authoring remain refused in Kinet's hosted mode.
Business API artifacts
Start with the APIs your work already uses
In local authoring, name your own API description files before confirming the proposal. OpenUdon validates the selected files before Kinet commits them into the workflow package. Nothing is fetched implicitly.
For catalog-backed sources, an operator prepares the APItools catalog. You select a candidate and confirm its exact source digest before import. Import does not bind a step or approve a run.
Roadmap (tentative): upload API artifacts into your account and use them across workflows. The existing import foundation does not yet provide that account library.
Runs use the APIs you approve
Before execution, Kinet shows the destinations, methods, effects and request rules. A one-off approval covers one run. A recurring schedule needs separate approval of its cadence, expiry and finite limits; renewal requires fresh review.
API keys and bearer tokens are write-only: Kinet stores them without a read-back route and injects them itself, so they never reach the runner.
Roadmap (tentative): more services and authentication methods.
Execution
Execution follows the document’s rules
UWS defines portable execution semantics. A run uses an identified Udon executor, and approval remains separate from authoring and import.
External services and model-backed steps can return different data. Deterministic execution rules do not guarantee identical results.
Running workflows
You can author a workflow, approve the exact package and run it.
A run follows the document’s rules in an isolated runner. The runner holds no credentials and makes no network calls itself: Kinet’s controlled broker sends the HTTPS requests you approved, and only those.
If a result is uncertain, Kinet records it as unknown and never retries a possible write automatically.
Inspect the plan and its history
Kinet records what you asked, what it proposed, what you approved and what happened.
Browser views
Chat, project goals, activity and approvals, with step cards for workflow authoring.
Agent workspaces
Several named agents per user, each with its own workspace, ledger and history.
Saved authoring plans
A read-only view of the workflow's authoring plan, rather than a compiled execution graph.
Bring your requirements and API descriptions
Discuss technical questions or business customization with us.
Talk to us hello@kinet.com