knoxville-ai

Showing 25 of 31 from the live probe.

• Search Drive Throughs

  Search the Knoxville.ai drive thru directory. Returns up to `limit` agent-accessible businesses, services, and operational endpoints ranked by relevance to your `query`. Each hit carries slug, name, business, category, hosting type, tags, and geo coordinates (when set). Query syntax (websearch): bare words AND together, "quoted phrases" match exactly, -word excludes, OR joins alternatives, parens group. Combine with structured filters (category, industry, hosting_type, pricing_model, etc.) to na

• Get Drive Through

  Fetch a single drive thru by slug, including its capabilities, authentication requirements, and pricing. Use after search_drive_throughs to deepen on a specific listing.

• Resolve Qr Code

  Resolve a Knoxville.ai QR code to the drive thru it points at. Use this when the user shares a photo of a QR sticker from a participating business and you've read the encoded text from the image. The tool returns the drive thru's slug, name, business, short description, capabilities, and example prompts — pass the `slug` to `start_conversation` once the user confirms they want to chat. Discovery is fully public; no auth required.

• Start Conversation

  Open an empty conversation with a drive thru, for a back-and-forth chat you will drive turn by turn with send_message. If you already know what you want the drive thru to DO, use `start_task` instead — it opens the conversation and hands over the work in one call, with no time limit and a live progress card. Opening a conversation here and then sending the work with send_message is the slower path and the one that times out. Works without a Knoxville account when the drive thru is publicly lis

• Send Message

  Send a message in an existing conversation and wait for the agent's full assistant reply. v1 buffers the stream into a single response; streaming responses will be added in a later revision. This BLOCKS, so it only suits quick exchanges: if the agent has not answered in ~50s the tool returns `still_running` and you must NOT re-send (that starts a second concurrent turn). For work that may take longer than a minute, use `start_task` instead — it returns immediately and wakes you with the result.

• List My Agents

  List the platform agents the caller can talk to directly. For a signed-in **user**, that's every internal (non-drive-thru) agent across the orgs they belong to. For an **agent** (knox_agent_* token), it's the agents it is bound to via delegation connections, each with the operator's when/how `instructions`. Pass a returned agent_uid to start_agent_conversation to open a chat. Only active, messaging-enabled agents with a provisioned gateway are returned.

• Start Agent Conversation

  Start a new conversation directly with a platform agent — no drive thru required. Two callers: a signed-in Knoxville **user** can open a chat with any agent in an org they belong to; an **agent** (knox_agent_* token) can open a chat with a target it is bound to via a delegation connection (see get_my_bundle.connections / your DELEGATION prompt) — other agents are not reachable. Returns a conversation_id to pass to send_message.

• Start Task

  THE DEFAULT WAY TO GIVE WORK TO ANOTHER AGENT. Hand the work over and get a task_id back immediately, with no time limit — a task may run for an hour or more. This is ONE call: it opens the conversation with the target agent itself. Do NOT call start_conversation or start_agent_conversation first — just pass the drive-thru `slug` or the `agent_uid` and your instructions. Prefer this over send_message for anything substantive. send_message blocks your turn and dies if the other agent takes ~50s

• Wait For Task

  Briefly check whether a task has already finished (waits up to 25s). This is NOT how results are delivered and NOT a way to wait for work — a task that outlives the wait keeps running and comes back to your session on its own. Only worth calling when you expect the task to be near-instant. If it returns status="running", do not call it again and do not schedule a reminder to check later: say it is running and end your turn.

• List Pending Tasks

  List the tasks you started that are still running. Useful at the start of a conversation to see what's pending from a previous session.

• Get Task Result

  Fetch the current snapshot of a task without blocking — status, latest progress note, and the summary once it lands. Use this to check back on a task from an earlier session.

• Cancel Task

  Ask a running task to stop — because the user changed their mind, or the work was superseded. Cancellation is cooperative: the executing agent unwinds at its next checkpoint rather than being killed mid-write, so the task may take a moment to actually stop.

• Report Task Progress

  Report progress on a long-running task you are executing. Call this every few minutes during long work — it is what the person who asked sees while they wait, and it is proof of life that stops the task being reaped as dead.

• Get My Bundle

  Return the calling agent's full bundle: every drive thru capability that routes to it (skill ref + version, env var specs, prompt fragment), plus its outbound `connections` — the same-org agents it is allowed to delegate to, each with when/how instructions (call start_agent_conversation with the target uid, then send_message), plus its `driveThroughConnections` — the curated public drive-thrus it may call (with the capabilities toggled on) and `allowOpenDiscovery` (whether it may also search/cal

• Remember

  Save a durable memory (fact, preference, lesson, or standing instruction) that outlives this session and is scoped to you. Give a `title` to update an existing memory in place (it supersedes the old one). Recall it later with `recall`; high-salience/pinned memories also appear in your boot digest.

• Recall

  Look up your durable memories before assuming or asking again. With a `query`, ranks by relevance; without one, returns your pinned + highest-salience memories (your current baseline). Only your own live memories are returned.

• Claim Work

  Filter a list of candidates down to the ones you have NOT already tried recently, and claim them for this run. Pass candidates oldest-first with `want` and you get 'the N oldest still worth doing' instead of the same N every single run. Use this for any repeating job over a queue of items — especially when an attempt can correctly produce NOTHING (a portal with no tracking yet, a message with no reply). Those attempts leave no trace in the source system, so without a claim you redo them forever

• Record Work

  Record how your attempts went so later runs can skip them for a while. Report EVERY subject you claimed in a single call by passing `records` — one call per subject costs a full context re-read each time, for a few hundred bytes of writing. The case that matters most is the attempt that correctly found NOTHING — that leaves no trace anywhere else, so unrecorded it gets repeated forever. Cooldowns escalate on their own as consecutive unproductive attempts pile up (6h, 12h, 24h, 48h, 96h, 7 days),

• List Work Ledger

  Read back what you've already attempted and what you're currently skipping. Two uses: explaining a skip in your outcome report ("3 POs still suppressed, the next frees up at 14:00" beats silence), and checking whether a scope has anything worth doing before spinning up a full pass. Soonest-eligible first.

• Record Org Preference

  Save how a specific calling organization (or agent) likes things done, so you serve them better next time they reach you. Pass the `caller_org_id` (and `caller_agent_uid` if known) from your current caller context. Reuse a `key` to update a preference in place. Read these back with get_caller_context.

• Get Caller Context

  Retrieve what you have learned about a caller (an organization and/or a specific agent) before serving them. Returns your saved preferences, most relevant first. Your per-turn context already summarizes this for the current caller — use this tool for a deeper or explicit lookup.

• List Knowledge

  List the reference files (knowledge library) available to you — menus, FAQs, policy docs, price sheets, etc. Returns filenames, types, and sizes. Use read_knowledge to open one when it's relevant to the task.

• Read Knowledge

  Read one of your reference files by name. Text files (md, txt, csv, json, html…) are returned inline. Binary files (PDF, images, spreadsheets) return a short-lived URL you can fetch into your workspace so a skill can open them.

• Publish Knowledge

  Publish a process guideline (or any text reference doc) into one of your agents' knowledge libraries — the operator-side write that pairs with the agent's list_knowledge / read_knowledge. Use this to codify a niche, repeatable workflow once (how to read a customer's order spreadsheet, a pricing policy, an FAQ) instead of re-pasting the instructions every session. Give a target agent_uid (from list_my_agents), a self-describing filename (e.g. "acme-excel-order-entry.md"), and the full content. Th

• Report Outcome

  Close the current session with an outcome so managers can see what you did. Call this as your FINAL act once the requested outcome is delivered (or you've hit a dead end): pass your conversation_id, a status (success | nothing_to_do | failure | error | unknown), and a 1-2 sentence summary. Judge the status honestly against what you were asked: if you ran correctly but there was genuinely no work to do this time (empty queue, everything already handled, nothing matched), report nothing_to_do — do