# One AI agent. 458 apps.  _Everywhere work happens._

An agent is a worker with tools, not a chatbot. Give it instructions, hand it **any of TinyCommand’s 458 apps in one click**, and put it where the work is: **embedded on your site** like a chat widget, or **dropped into a workflow** as a step. It thinks and picks the right tool, and you can have it stop for your sign-off before it acts.

### 458 apps, one click
- Lives inside your workflows
- Embeds on your site, like chat
- Six agents ready to run
- Sign-off before it acts
- Answers from your PDFs

### Plan the work
“New lead from Acme Robotics. Research the company, score intent, update the CRM, then draft outreach, and get it approved before sending.”

```json
{
  "company": "Acme Robotics",
  "intentScore": 82,
  "fit": "high"
}
```

### Update Record
```json
{
  "table": "Leads",
  "status": "hot"
}
```

### Human Approval
“Per the instructions, pause for a person to approve before anything is sent.”

## Drop an agent into your chat, _or onto your site._

Take a finished agent and put it where your customers already are. Paste one line of code on your website, or add it to a chat. Give it your own knowledge as a PDF and it answers from your content, in your voice, with replies that stream in as it writes.

### One line on your site

```html
<script src="https://agent.tinycommand.com/widget.js" data-agent="docs-assistant" defer></script>
```

_Answers from your PDFs_ _Streams its replies_ _Voice questions_ _Themeable widget_ _Version history_

### Hand it any of _458 apps_. One click.

Every integration TinyCommand has is your agent’s to use. No glue tools, no per-connector fees. Pick the app, pick the action, and it becomes a tool: the agent decides what goes in the fields at runtime, and pauses for your approval where you ask it to.

1. **Pick the app** _search all 458_
   
2. **Pick the action** _“Send email” · “Add row” · “Post message”_
   
3. **It’s a tool now** _the agent fills the fields at runtime_

### And your workflows can _hire it too_.

The agent is a real step on the workflow canvas, right next to If/Else and your app actions. Mid-run, the workflow hands it a message; the agent thinks, uses its tools, and hands its answer to the next step. The same agent you embed as a chat widget is the one your workflows call.

### Watch it think, pick a tool, and _check with you_ before it acts.

Given a goal, the agent does not answer in one shot. It makes a plan, picks a tool, reads what comes back, and decides the next move, repeating until the job is done. You can see the whole run: every thought, every tool it used and what it got, and a pause for your approval before it sends anything.

### Final answer
“Approved. Lead qualified as hot, CRM updated, and a personalized first-touch email is ready to send.”

```json
{
  "status": "qualified · hot",
  "rowId": "rec_8841",
  "email": "ready_to_send"
}
```

## Every action your platform can take is a _tool the agent can pick up_.

The agent is the brain. Tools are its hands. Web search, scraping, reading documents, looking up people and companies, your TinyTables, and every one of your 458 connected apps are all tools on the same canvas, the very same building blocks that power your workflows. Each one has a clear input and a clear output, so the agent runs a real action instead of guessing.

### Good to know.

New to agents? Start with [the complete no-code AI agent guide](/content/tinyagents/guide/index.html).

### How is this different from a chatbot?

A chatbot answers from a knowledge base. A TinyAgent does work. It makes a plan, picks the right tool, reads each result, and decides the next step, repeating until the goal is met, and you can add a sign-off step so it waits for your approval before anything important happens. You can also step through the whole run to see exactly what it did.

### Is there a free plan?

Yes. Build and test an agent for free, and you are in the builder in under a minute.

## Someone asks on your site, and your agent takes it from there.

No wiring to build. Every step hands off to the next on its own.

### All it takes is a TinyCommand.

**Five products. One system.** One place everything lands.