Your agent does the wrong thing because it was never told the right thing

Instead of handing the model one constant prompt, migrate that information (instructions, tool descriptions, skills, plus annotated traces) into a separate knowledge base. At inference time, only the artifacts relevant to the current input are placed in context.

Why move it out of the prompt

Triage a failure to the instruction behind it

Searching a prompt finds a string. It can't tell you which instruction actually drove a decision, and the one responsible often doesn't mention the symptom at all. When several instructions conflict, nothing tells you which one won. Provenance records exactly what was in context and what the model acted on.

A managed service that gives your agent the best knowledge context for each input at inference time. Connect in a few lines, then let the engine find the right configuration automatically, or turn the knobs yourself.

# retrieve-and-inject: you get the context, pass it to any model
from openai import OpenAI
import kinesthetic

client = OpenAI()
kb = kinesthetic.connect("banking-support")

# retrieve only the artifacts this input needs, as system messages
context = kb.retrieve(input=user_message)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        *context.as_messages(),   # e.g. refund-policy v3, tone-guide v7
        {"role": "user", "content": user_message},
    ],
)

# decorate your agent's completion call — once
from openai import OpenAI
import kinesthetic

client = OpenAI()

@kinesthetic.engine("banking-support")
def respond(messages, tools):
    # nothing else changes. on every call the engine reads the full
    # request and injects the right artifacts before it's sent
    return client.chat.completions.create(
        model="gpt-4o",         # whatever model the agent runs on
        tools=tools,            # every tool the agent can call
        messages=messages,      # the full prompt + message history
    )

Onboarding is a one-time upload

Point us at your existing prompts or a legacy knowledge base and we ingest them once. Connect with whichever mode fits your harness, and you're retrieving. No re-platforming, no rewrite of your stack.

By disentangling the specification from the agent harness and engineering stack, into a structure intentionally designed for it, we can build powerful, user-friendly tools for the whole team to understand and shape agent behavior. Engineers, SMEs, and product people work on the same artifacts.

Artifact-level version control

The knowledge base is managed like a git repo. Artifact-level history, branching, pull requests, and automated merge guardrails all fit naturally, so a change to how the agent behaves is a reviewable diff, not a mystery edit to a prompt.

Query, and every other action

Search it like a document store, or run the same retrieval process your agent uses to surface relevant artifacts for an investigation. Every action can be done through code, through our agent, or by hand.

A big part of how Kinesthetic makes agents work well is by synthesizing and enriching the artifacts an agent uses at inference time. These machine-authored data are created when Kinesthetic learns what the agent does in production, or through offline inspection, and they are always treated as derived from human-authored ground truth.

Why purpose-built retrieval wins

None of this is a one-time setup. Once your specification is a knowledge base your team operates, Kinesthetic becomes a closed-loop system that improves by running, and the work compounds. The same structure that makes failures auditable turns every correction into durable, proprietary value.

Where Kinesthetic fits

Not every AI system needs Kinesthetic. We built it for the class where specifying how the AI should behave exceeds the capabilities of vanilla knowledge implementations, and creates operational challenges for the humans shaping it.

AI system taxonomy