Tiro turns every meeting into business context
your agents can use the moment it ends.
Trusted by 200+ companies worldwide.
THESIS
More than 90% of critical decisions happen in meetings — and disappear the moment they end.
ChatGPT, RAG pipelines, and agents operate without the institutional context that defines how your business actually runs.
The bottleneck isn't model performance. It's the absence of organizational knowledge at the point of inference.
PRODUCT
Tiro captures every conversation accurately and turns it into a record your whole company can rely on.
People, agents, and tools all work from the same source — and finally understand how your business actually runs.
Press Start Recording below and the transcript appears here.
Decisions
SOC 2 Type 2 targeted for 2026-06. ISO 27001:2022 Stage 2 in progress through 2026-05.
Verified
Zero Retention DPA signed with every vendor. AES-256 at rest, TLS 1.3 in transit, per-user KMS key isolation.
Next Steps
Bob shares the Type 2 timeline with the security team. Alice drafts Stage 2 materials within a week.
Real-Time Transcription
Speech to text in under 0.5s.
Works Everywhere
Web, desktop, mobile, smartwatch, phone calls.
Speaker Labels
Tagged per team member, automatically.
15+ Languages
Automatic detection. Live translation.
Accuracy
Context-aware recognition for your domain.
No meeting bot
Captures system audio directly. No third party in the attendee list.
USE CASES
Tiro captures every customer meeting. MCP pulls the full account history in a single call.
Claude uses that context to draft the follow-up, update the internal brief, and prep the next meeting.
On the morning of each meeting, the Tiro CLI drops a summary of the last call into Slack.
The moment a meeting ends, a webhook fires. Decisions land in your internal systems in real time.
Teammates who weren't in the room see the outcome on their own dashboard, in their own language.
Accumulated context flows into Confluence and CRM — ready the next time the team needs it.
Attorneys take consultations in their own mobile app. Recordings flow into Tiro's STT API.
Case names, statutes, and citations are captured accurately. A structured payload posts to the CRM via webhook.
The same payload feeds the in-house legal LLM. Case-law search and document drafts begin automatically.
From the existing scheduling spreadsheet, a deep link launches Tiro with the right patient context.
When the consultation begins, Tiro auto-detects the language (KO · JA · ZH · EN) and starts recording.
Results post back to the spreadsheet via API. Patient context syncs to the in-house CRM — so care continues seamlessly across branches.
WHAT CUSTOMERS SAY
The limit of AI agents isn't model performance. It's the absence of business context. After advising 230,000 companies on AI at Channel Corp, that's the truth I'm most sure of. Most of that context is created in meetings — and most companies let it slip away. Tiro isn't a note-taker scooping it up afterward. It's the infrastructure that builds your agents' memory.
Kyunghoon LeeSoon, human meetings will be a way to feed information to the agents. To sync ontologies between agents and clean up the overlaps. Tiro is a great way to pass an organization's tacit knowledge without anyone having to type it out themselves.
Jaekyu Lee (JQ)Tiro protects what I value most: time. Recording and summarization, automatic. Language barriers, gone. I spend almost no time on meeting follow-ups now — and I can put that time into deeper judgment calls.
Taekkyung LeeTiro completely changed how my meetings work. With 3+ hours of meetings a day, I was hitting the limits of memory. I can't work without Tiro now. The time I used to lose to note-taking is gone. Decisions land in our systems automatically.
Youngjoon YooThe anxiety of missing something in a meeting is gone. I can focus on the conversation without worrying about losing details. After investment meetings, my IC memo writing dropped to one-third. The next meeting starts with the same account context already loaded.
Yujin ChoFor teams whose agents need meeting context directly. One line to install. One word to call.
Install the Tiro MCP server in this workspace.
Server URL : https://mcp.tiro.ooo/mcp
Transport : HTTP (streamable)
Auth : OAuth (preferred). On first connection, the user opens
a browser for Google sign-in. Tokens cache locally for
180 days.
IMPORTANT: You (the AI) cannot open a browser or click "Authenticate"
yourself. After install, instruct the user to complete the OAuth step
in their MCP client.
Per-client install commands:
· Claude Code (CLI):
claude mcp add --transport http --scope project tiro \
https://mcp.tiro.ooo/mcp
Then ask the user to run /mcp inside Claude Code and select
"Authenticate" on the "tiro" entry.
· Claude Desktop / Cursor / VS Code:
Edit the MCP config (claude_desktop_config.json, Cursor MCP
settings, .vscode/mcp.json) and add an HTTP entry pointing at
https://mcp.tiro.ooo/mcp. The user signs in via OAuth on first
load.
· stdio-only clients (no HTTP support):
Wrap with mcp-remote:
npx -y mcp-remote https://mcp.tiro.ooo/mcp
If the user cannot run a browser flow (CI / headless / sandbox), ask
them for a Tiro API key from
https://platform.tiro.ooo/dashboard/api-keys and attach the header:
Authorization: Bearer <TIRO_API_KEY>
After install, MCP tools usually only appear after a session restart.
Tell the user to restart, then call `auth_status` to confirm the
session is live and list the Tiro tools that loaded. If any step
fails, show the exact error and the step where it happened — do not
retry silently.For teams pushing meeting outcomes into the systems they already run. JSON responses, auth, and pagination — included.
Set up Tiro REST API access in this environment.
Base URL : https://api.tiro.ooo
Auth : Bearer token (API key = id + "." + secret)
Content : application/json
IMPORTANT: You (the AI) cannot create the API key. The user must
generate it themselves and paste it back. Walk them through it.
Steps:
1. Tell the user to open
https://platform.tiro.ooo/dashboard/api-keys, create a new key,
and copy the FULL string — id, dot, and secret together. The
secret is shown only once. Using only the id portion will fail
with 401.
2. When the user pastes the key, store it as an environment
variable. Never hardcode. Pick the right target:
· Project-scoped: write to .env.local (or .env) and add it
to .gitignore.
· Shell-scoped: append to ~/.zshrc (or ~/.bashrc) so it
persists across sessions.
Example:
export TIRO_API_KEY="<paste-id.secret-here>"
3. Test the first call (list notes):
curl https://api.tiro.ooo/v1/external/notes \
-H "Authorization: Bearer $TIRO_API_KEY" \
-H "Content-Type: application/json" \
-w "\n%{http_code}\n"
Expected response: JSON with `content[]` array of notes,
each containing `guid`, title, createdAt, status. Pagination
via `nextCursor`.
If you get 401, check the Bearer string contains the dot separator.
If you get 429, you hit the hourly rate limit — wait before retry.
Show the user the exact error payload — do not retry silently.
Full reference: https://api-docs.tiro.ooo/fundamentals/api-overviewFor engineers who live in the terminal. Search and cite meeting context from your shell. Drop into automation scripts.
Install the Tiro CLI in this environment and sign me in.
Package : @theplato/tiro-cli (Node.js 20+)
Platforms : macOS, Linux, Windows
Auth : OAuth (Authorization Code + PKCE) — opens a browser
and stores the token in the OS keychain.
Steps:
1. Install globally with whichever package manager is already in
use here. For npm, that is:
npm install -g @theplato/tiro-cli
(Use pnpm / yarn / bun equivalents if those are the active
package manager — do not switch tooling. If no lockfile is
present, default to npm.)
2. Verify the install:
tiro --version # expect 0.3.1 or later
3. Detect environment:
· If `$DISPLAY` is set OR `open`/`xdg-open` is available:
treat as interactive → proceed to OAuth.
· If `$SSH_TTY` is set, or `$CI` is set, or no display open
command exists: treat as headless → skip OAuth.
4. Interactive path — sign in:
tiro auth login # opens a browser for OAuth
tiro auth status # confirm: shows user + token prefix
5. Headless path — ask the user for a token instead:
export TIRO_TOKEN="<paste-token-here>"
The token is generated by visiting the same login URL in a
browser-equipped machine and copying the result.
6. Prove the CLI works:
tiro notes list --limit 3 --json
Show me the output. Exit code 0 = success, 4 = auth required
(go back to step 4 or 5), other = report the JSON error
envelope verbatim.For teams where the next piece of work starts the moment a meeting ends. Event-driven automation across your systems.
Set up a Tiro webhook endpoint to receive note events.
Method : POST with application/json body
Auth : Bearer token in Authorization header
Tiro sends: Authorization: Bearer <WEBHOOK_SECRET>
You compare it against your stored secret using a
constant-time compare (e.g. crypto.timingSafeEqual).
Timeout : 60 seconds per delivery
Retries : Up to 5 with exponential backoff over ~2 hours
IMPORTANT: You (the AI) cannot register the endpoint in the dashboard.
The user must do step 1 themselves and paste the secret back.
Steps:
1. Tell the user to register their HTTPS endpoint at
https://platform.tiro.ooo, copy the WEBHOOK_SECRET shown after
registration, and paste it here. Store it as an env var (use
.env.local for project scope; never commit):
export WEBHOOK_SECRET="<paste-here>"
2. Build an HTTP POST handler that:
a. Reads the Authorization header.
b. Strips "Bearer " and constant-time-compares the remainder
to WEBHOOK_SECRET. Return 401 on mismatch.
c. Parses the JSON body into { id, type, createdAt, data }.
d. Routes by `data.resourceType`:
- Note (note.created/updated/deleted)
- NoteSummary (noteSummary.created)
- NoteDocument (noteDocument.created/updated)
- FolderNoteRelation (folderNoteRelation.created/deleted)
e. Tracks event.id in a durable processed-set for idempotency
(Redis / DB in production; in-memory only for local dev).
Retries with the same id are EXPECTED — return 200 with
{ status: "duplicate" } on repeat.
f. Returns 2xx on success, 5xx for transient (will retry),
4xx for permanent (no retry).
3. Pick one language (Node / Python / Go / Kotlin+Spring) the user
is already on, write the receiver code, and show how a
`note.created` event flows end-to-end.
4. Test:
curl -X POST <endpoint> \
-H "Authorization: Bearer $WEBHOOK_SECRET" \
-H "Content-Type: application/json" \
-d '{"id":"evt_test","type":"note.created","createdAt":"2026-05-18T00:00:00Z","data":{"resourceType":"Note","id":"n_1"}}'
Expect 200 within 60 seconds.
Full reference:
Events: https://api-docs.tiro.ooo/webhooks/events/schema
Best practices: https://api-docs.tiro.ooo/webhooks/best-practicesYour conversations never train or fine-tune any model.
AES-256 at rest. TLS 1.3 in transit.
Isolated per-customer keys.
Deleted the moment transcription completes.
Never stored. Never archived.
SAML SSO · MFA · SCIM · IP allowlist.
Native to your IdP.
PRICING
Self-serve with Team. Talk to us for Enterprise.
For teams of up to 20 people. Set up in minutes, no sales call needed.
2 months free with annual billing
Start your 2-week free trialFor organizations with security, scale, or compliance requirements. Includes dedicated rollout and support.
Lightweight notes and summaries.
The standard for everyday users.
300 minutes of free trial credit. 60-minute per-note limit. All Pro features included.
The Team plan is for teams that want to start immediately without procurement — ideal for teams under 20 that need to add members and collaborate without delay. The Enterprise plan is built for larger organizations that need security controls aligned with internal policies, dedicated infrastructure, and a dedicated support channel.
Yes. If your small team needs options aligned with your internal environment, the Enterprise plan covers it. From onboarding to support model to security controls, we design a setup that fits your situation. Want to see what a rollout could look like? Talk to us any time.
Audio deleted immediately: Recorded audio is permanently deleted the moment transcription completes. Never archived. Never recoverable.
Data residency: All data stays within the AWS Seoul region.
Data isolation: Text data is encrypted with customer-specific keys. Your data is physically and logically separated from every other tenant.
No model training: Your conversations are never used to train any model — ours or our vendors'. Zero Data Retention agreements are in place with every LLM and STT vendor we use.
For more security details, see our Trust Center.
Tiro supports API, MCP, and CLI — three connection paths. Pick the one that fits your agent environment.
Install directly from the Connect section, or see the Tiro API docs for auth, endpoints, and command details.
The Tiro API is the programmatic interface for accessing Tiro data from external systems (note search, audio processing, and more). The Tiro MCP is the integration that lets AI agents like Claude use Tiro notes as context directly.
Both are available on every plan.
The Tiro CLI is built for shell environments, CI pipelines, scheduled jobs, or agents like Claude Code — anywhere you need results directly to disk or stdout. Common uses: bulk search and export of meeting notes, piping transcripts as JSON, and scripted automation.
Token efficiency is another reason to choose CLI. Where MCP loads thousands of tokens into context, the CLI uses a fraction per command — better for cost and speed.
Team Plan is billed by credit card with monthly or annual options. Annual billing comes with 2 months free. Invoices are auto-generated for every payment (including card) and downloadable any time from the admin page. If your accounting team requires bank transfer instead, we support this on annual prepayment terms — just reach out.
Enterprise Plan supports credit card, bank transfer, and purchase orders. Annual contracts are the default, with quarterly or semi-annual installments available. Default currency is USD, with KRW and JPY invoicing and tax documentation available on request.