# Agent runs
Source: https://docs.strawberrybrowser.com/ai/agent-runs
Understand agent work, work traces, sub-agents, feedback requests, interrupted work, and how to review what Strawberry did.
An agent run is a companion doing work, not just replying. It may search, open tabs, read web pages, use connected apps, create files, run code, ask for feedback, or spawn sub-agents.
## What agent runs can do
Depending on permissions and available tools, a companion can:
* Search the web
* Read and compare pages
* Open and navigate tabs
* Use connected app tools
* Read and write workspace files
* Create reports, spreadsheets, documents, and artifacts
* Ask follow-up questions
* Run sub-agents for scoped investigations
## Work traces
Strawberry shows work traces so you can inspect what happened. A work trace can include:
* Searches
* Tool calls
* File operations
* Browser actions
* Sub-agent activity
* Questions and feedback requests
* Progress from a `PLAN.md`
Use the work trace to audit sources, understand decisions, and resume from partial work.
Completed connected-app actions may include a short **Go to ...** button that opens the created or updated item, such as a document, spreadsheet, email, draft, or calendar event.
## Sub-agents
Sub-agents help split complex work into smaller tasks. For example, a market research task might spawn separate sub-agents for competitors, pricing, customer reviews, and source validation.
Each `strawberry.startAgent()` sub-agent can get its own `PLAN.md` in that sub-agent's session folder.
## Feedback requests
Companions can ask for feedback when they need a decision, permission, missing data, or human judgment. Some feedback requests appear in the chat, sidebar, or right-side panel.
## Interrupted sub-agents
If a sub-agent is interrupted, Strawberry can show a banner so you can reopen or resume the thread. Review the context before continuing, especially if the task involved browser state, credentials, or an external app.
## Best practices
* Give clear success criteria before starting a broad agent run.
* Ask for source links and confidence levels when research quality matters.
* Review work traces before relying on a generated file.
* For sensitive workflows, say what the companion may do automatically and what requires approval.
* For long tasks, ask Strawberry to create a plan first.
# Chat
Source: https://docs.strawberrybrowser.com/ai/chat
Use Strawberry chat, queued follow-ups, steering, stopping, attachments, context, and companion selection.
Chat is the main place where you talk to companions, attach files, reference tabs, review work, and continue tasks.
## Queued follow-ups
When a chat is already responding, you can type another message and send it. Strawberry adds it to that chat's queue.
Queued messages:
* Run one at a time in the order sent.
* Stay specific to the current chat.
* Include their own attachments, files, selected text, windows, and tabs.
* Show a short text preview above the chat input.
When a queued message starts running, it leaves the visible queue. Remaining items stay visible.
## Steer a queued message
Click **Steer** on a queued message to make it run next. Strawberry stops the current response and sends the steered message first. Other queued messages stay queued.
## Stop and send immediately
Press `Cmd+Enter` on macOS or `Ctrl+Enter` on Windows/Linux while a chat is responding to stop the current response and send the typed message immediately instead of queueing it.
If the chat input is empty and queued messages are waiting, pressing `Enter` stops the current response and sends the next queued message.
## Attach files and context
You can paste or drop files into chat. Strawberry waits for attachment processing before creating a new chat from the new tab page.
You can also give a companion tab context, selected text, files, or explicit instructions about what to inspect.
Use `@` in the chat input to mention open tabs, and apps.
## Companion selection
Use the companion picker in chat to choose who should handle the task. Press `Cmd + .` to cycle through companions. Use `Shift` to cycle backward.
## Good chat prompts
Good prompts explain:
* Goal
* Context to use
* Constraints
* Output format
* Whether the companion should ask before acting
```text theme={null}
Research these 25 companies.
Use their official websites and LinkedIn pages when possible.
Return a spreadsheet with company, website, HQ, size, target buyer,
evidence URL, and a one-sentence reason they fit.
Ask me before sending any outbound messages.
```
# Companions
Source: https://docs.strawberrybrowser.com/ai/companions
Learn what companions are, how they differ, what they can access, and when to create separate companions.
Companions are Strawberry's AI assistants. They live inside the browser, can use the context you provide, and can be specialized for different kinds of work.
A companion can have:
* Its own instructions and personality
* Companion-specific files
* Companion-specific memory
* Companion-specific skills
* Companion-specific routines
* Access to profile-level connected apps
* Shared access when you share the companion with another user or team
## When to use one companion
Use one primary companion when your workflows are closely related and should share the same context. For example, a founder might keep one companion that understands their company, tone, customers, and calendar.
## When to create multiple companions
Create separate companions when you want different instructions, memories, or routines:
* A sales companion for outreach and CRM work
* A recruiting companion for sourcing and candidate screening
* A research companion for market maps and competitive analysis
* An operations companion for recurring inbox, invoice, and reporting workflows
## Companion settings
Open a companion's settings to manage:
* General details
* Files
* Apps
* Skills
* Routines
* Sharing
The **Files** tab opens the filesystem roots the companion can use, including the companion folder, your workspace, and team workspace when available.
## Companion-specific skills
When you create a skill from companion settings, Strawberry saves it in that companion's own **Files -> \[companion name] -> skills** folder. These skills appear before global skills in the chat slash menu and follow the companion when shared.
## Sharing companions
Companions can be shared with another Strawberry user, specific team members, or a whole team. Sharing grants access to that companion's synced folder, including instructions, memories, observations, and companion-specific skills.
Chat history is not shared. When someone opens a shared companion, they start their own local chat with it.
Companion sharing currently grants edit access. Recipients can update the companion's settings,
memories, and skills until sharing is stopped.
## Best practices
* Put stable, reusable context in memory or skills instead of repeating it in every chat.
* Use separate companions for workflows with different tone, permissions, or app needs.
* Review companion sharing before putting sensitive files or instructions into a companion folder.
* Keep companion instructions specific enough to guide behavior, but not so rigid that the companion cannot ask clarifying questions.
# Credits and usage
Source: https://docs.strawberrybrowser.com/ai/credits-usage
Understand Strawberry credits, monthly plan credits, top-ups, rate-limit windows, agent costs, and why credits can drop.
Credits are Strawberry's usage unit for AI work.
## Core rules
* Browsing websites without companion help does not consume credits.
* Any companion AI response can consume credits, including normal chat replies.
* Agent runs, web research, app actions, and complex workflows usually consume more credits than simple chat messages.
## Credit accounts
A credit account is a separate balance that Strawberry can use for AI work. You always have a personal credit account. If you join a team, you can also have a team credit account.
One credit account is active at a time. New companion replies, agent runs, research, and other AI work use the active account. Personal and team balances stay separate. Switching accounts does not transfer or combine credits.
To see every available credit account and choose the active one in Strawberry:
1. Open the profile menu in the top-right corner.
2. Open **Credit account**.
3. Review each balance and select the account you want to use.
On the web, open **Account** -> **Billing & usage** -> **Credit account**.
Strawberry calls this a **credit account** in user-facing screens. A billing account is the internal record used for subscriptions, invoices, and credit accounting.
## Why credits can drop without an agent run
A regular chat turn still calls an AI model. Model input and output tokens are billed as usage cost even when no separate agent block appears.
Fast and Smart mode both use adaptive thinking when the selected model supports it.
Smart and Fast mode use Claude Sonnet by default. Advanced companion settings can switch Smart mode to premium models, which may use more credits, especially on long-context requests.
## Free plan task sizing
On free plans, Strawberry may right-size very large requests by doing a smaller representative version first. For example, it may find 10 leads before scaling to 100, review a few rows before cleaning a full spreadsheet, or analyze a few competitors before building a broad market map.
If you want the larger batch after reviewing the sample, ask the companion to continue or scale it up.
## How to check usage
1. Open `strawberry://settings/account`.
2. Review the **Usage overview** credits card. It shows the active credit account.
3. In a chat, open the content panel to see credits used by the current chat, account credits left, and any active rate-limit window.
4. Open `strawberry://settings/pricing` for plan limits and billing information.
## Reading the credits bar
The credits bar appears on `strawberry://settings/account`, `strawberry://settings/pricing`, the main settings menu, and the profile menu.
* The headline shows the credits remaining in the active credit account.
* If you have more than one credit account, the account name appears with the balance.
* Personal monthly credits are used before personal top-up credits.
* Team seat credits are used before an eligible shared team pool.
* Top-up credits do not expire.
* The gray part of the bar is what you have already used.
Balances from inactive credit accounts are not added to the active account's bar. Open **Credit account** to compare them.
## Rate limits versus plan credits
Plan credits are your monthly included usage. Rate-limit windows are short-term guardrails that can temporarily limit activity even if you still have monthly credits.
If a rate-limit window appears, wait for the displayed refill time or reduce task intensity.
## Running low
You can:
* Continue with smaller tasks.
* Ask the companion to produce a representative sample first.
* Buy top-up credits.
* Upgrade to a higher plan.
* Switch to another credit account that has available credits.
* For teams, use included seat credits, an eligible shared pool, or metered usage when your team has enabled it.
# AI permissions
Source: https://docs.strawberrybrowser.com/ai/permissions
Control what companions can do through permission mode, connected app tool permissions, folder access, and chat-specific approvals.
AI permissions let you decide what companions can do automatically and what requires approval.
Open AI permissions at `strawberry://settings/ai-permissions`.
## Permission mode
1. Open `strawberry://settings/ai-permissions`.
2. Under **Permission Mode**, choose:
* **Default**: standard permission rules for each action type.
* **Ask Always**: ask for confirmation before every action.
## Connected app tool permissions
Each connected app can have tool-level permissions.
1. Open `strawberry://settings/integrations`.
2. Open an integration's detail page.
3. In **Permissions**, set each action to:
* **Ask every time**
* **Always allow**
* **Disable action**
You can also see configured permissions at `strawberry://settings/ai-permissions` under **Permanent Permissions**.
## Permanent and chat-specific permissions
* **Permanent permissions** apply across chat sessions. Manage them per integration.
* **Chat-specific permissions** apply only to one chat session and are cleared when that session ends.
## Folder access requests
When a companion needs access to local folders, Strawberry can ask for folder permissions. On Windows, folder grants are especially important for sandboxed file access.
Only grant folders that are relevant to the task.
## Sub-agent feedback requests
Sub-agents may ask for help when they need a decision, missing information, or approval. These requests can surface in chat and related UI.
## You stay in control
Use stricter permissions for workflows that can send messages, spend money, mutate business systems, delete data, or access sensitive local folders.
Do not set broad "Always allow" permissions for tools you do not fully trust. A narrow permission
setup is usually better than a convenient one for sensitive apps.
# Plans and todos
Source: https://docs.strawberrybrowser.com/ai/plans-and-todos
Use Strawberry's PLAN.md system for durable planning, visible progress, sub-agent work, and approval before execution.
Strawberry has a built-in plan and todo system for multi-step work.
The source of truth is a `PLAN.md` file at the root of the chat session workspace. The companion creates and updates this file with normal file tools. Strawberry parses structured todo blocks and shows the current plan in the chat UI.
## How plans work
* One chat session has one canonical `PLAN.md`.
* Each sub-agent can have its own `PLAN.md`.
* Markdown headings and prose are used for plans, notes, sources, and decisions.
* Structured todo blocks represent user-visible execution state.
* Plans stream into the chat UI while they are written.
* Strawberry reparses the plan after successful file writes or edits.
## Todo format
Todos use XML-style blocks inside markdown:
```xml theme={null}
Find EU suppliers
in_progress
Capture URLs, pricing, lead times, and whether each supplier ships to Sweden.
```
Common states include `pending`, `in_progress`, and `completed`.
## What you see
In chat, Strawberry can show:
* The plan summary
* Current todo state
* Sub-agent progress
* Related tool activity
* A link to open the full plan file
## Approval before execution
Planning and execution are different. Creating or refining `PLAN.md` is planning. Marking work as `in_progress`, using tools, navigating pages, or taking actions can count as execution.
Use explicit approval when you want the companion to pause after planning:
```text theme={null}
Create a plan first. Do not start execution until I approve it.
```
## Best practices
* Ask for a plan when the task has multiple phases, dependencies, or risk.
* Keep plan todos specific and testable.
* Ask Strawberry to update the plan when scope changes.
* Use plans for work you may need to resume later.
# Memory and skills best practices
Source: https://docs.strawberrybrowser.com/best-practices/memory-and-skills
Decide what belongs in Strawberry memory, what belongs in skills, and how to keep both useful over time.
Memory and skills solve different problems.
* **Memory** stores stable facts and preferences.
* **Skills** store reusable process.
Use both when you want companions to improve without long prompts.
## Put facts in memory
Good memory:
```text theme={null}
Our ICP is B2B SaaS companies with 50-500 employees in the Nordics.
Primary buyer titles are VP Sales, Head of RevOps, and Founder.
```
Avoid:
```text theme={null}
Research these 12 companies by Friday.
```
That is a task, not durable memory.
## Put process in skills
Good skill:
```text theme={null}
When evaluating a prospect, inspect website, LinkedIn, funding news,
and CRM history. Score fit from 1-5 and cite evidence.
```
Avoid putting this process in memory unless it is a stable preference and not an executable workflow.
When a companion completes a repeatable workflow well, ask it to save the process while the details are fresh:
```text theme={null}
Create a skill for me from this workflow.
Ask me targeted questions if anything is missing before you save it.
```
## Keep both scoped
Use companion-specific memory and skills when only one companion should use the context.
Use global or shared memory and skills when all relevant companions should use them.
## Maintain over time
Review memory and skills when:
* Your product changes.
* Your ICP changes.
* You change tone or messaging.
* A routine starts producing noisy results.
* A companion repeats outdated assumptions.
## Ask Strawberry to help maintain them
Useful prompt:
```text theme={null}
Review this chat and suggest only durable facts that should be saved to memory.
Do not save temporary task details. Separate facts from workflow improvements
that belong in a skill.
```
If the same workflow should run on a schedule, create a routine instead:
```text theme={null}
Do this workflow every Tuesday morning.
Ask me what trigger, approval rules, and notification rules you need.
```
## Safety
Do not store secrets, credentials, personal data, or confidential customer data in memory or skills unless the scope is correct and there is a clear reason.
# Prompting best practices
Source: https://docs.strawberrybrowser.com/best-practices/prompting
Work with Strawberry companions by stating the outcome, planning together, asking targeted questions, and saving useful workflows as skills or routines.
Good Strawberry prompts are practical. Start by telling the companion what you want to do, then ask it to plan the work with you before it starts executing.
## Start with the outcome
For important tasks, begin with plain language:
```text theme={null}
I want to do [the thing].
Can we plan it out together before you start?
Ask me targeted questions that would help you do this better.
```
This works well because Strawberry can help define the scope, choose useful sources, spot missing context, and turn a vague request into a concrete plan.
## Example starter prompt
```text theme={null}
I want to build a shortlist of potential customers in Sweden and Denmark.
Can we plan it out together before you start?
Ask me targeted questions about ICP, source quality, output format, and what
you are allowed to do automatically.
```
After the companion asks questions, you can agree on details such as:
* Which sources to use
* How large the first sample should be
* What the final output should look like
* What requires approval
* How the companion should verify the work
## Give the companion permission boundaries
Say what it can do automatically and what it must ask about.
Useful boundaries:
* "Read only. Do not send, update, delete, or buy anything."
* "Draft emails but do not send them."
* "Create a sample of 10 rows first."
* "Ask before opening paid tools."
* "Use my CRM only for deduplication."
## Ask for verification
When accuracy matters, ask for:
* Source links
* Confidence notes
* Rows with missing data
* Assumptions
* A summary of how the companion checked its work
## Use memory and skills
Put stable facts in memory. Put repeatable process in skills. Then prompts can be shorter.
If a chat handles a workflow well, ask:
```text theme={null}
Create a skill for me from this workflow.
```
If the workflow should happen on a schedule, ask:
```text theme={null}
Do this workflow every Tuesday morning.
```
Strawberry can turn the successful pattern into reusable instructions or a routine, then you can review and adjust it.
## Common mistakes
* Asking for "everything" without a scope
* Omitting the source of truth
* Not saying what format you want
* Letting a companion infer approval rules
* Asking for a huge batch before testing a sample
* Repeating a successful workflow manually instead of turning it into a skill or routine
## Better follow-ups
Instead of restarting, steer the current task:
```text theme={null}
Keep the same table, but add a confidence column and only use official sources
for employee count.
```
# Research workflows
Source: https://docs.strawberrybrowser.com/best-practices/research
Run higher-quality Strawberry research with source rules, sampling, structured outputs, confidence, and review.
Research tasks are where Strawberry can save large blocks of time, but quality depends on clear instructions and review.
## Start with the decision
Tell Strawberry what decision the research supports.
```text theme={null}
I am deciding which 20 companies to prioritize for outbound this month.
Research fit, urgency signals, and likely buyer title.
```
The decision helps the companion choose sources and avoid irrelevant detail.
## Define source rules
Good source rules:
* Use official websites first.
* Use LinkedIn for company and people context.
* Use primary filings or databases when relevant.
* Avoid old blog posts unless they are the only available source.
* Mark uncertain data instead of guessing.
## Use samples before scale
For large tasks, ask for a representative sample first:
```text theme={null}
Do the first 10 companies, show me the output, and wait before scaling to 100.
```
This prevents wasted credits and catches formatting issues early.
## Request structured output
Use a table or spreadsheet when you need to compare results.
Include columns such as:
* Name
* URL
* Source
* Evidence
* Confidence
* Notes
* Next action
## Ask for gaps
Require a "missing or uncertain" section. This is better than forcing the companion to fill every cell.
## Review before acting
Before sending messages, updating CRM, or making business decisions, review:
* Source quality
* Data freshness
* Duplicates
* Uncertain rows
* Whether the output matches your constraints
## Best-practice prompt
```text theme={null}
Research 20 competitors in this market.
Use official websites, pricing pages, product docs, and recent primary sources.
Return a table with positioning, target customer, pricing model, strongest claim,
weakness, source URL, and confidence.
Do not guess. If data is missing, write "not found" and explain where you looked.
```
# Routine best practices
Source: https://docs.strawberrybrowser.com/best-practices/routines
Design useful routines that trigger at the right time, avoid noise, combine related actions, and ask for approval.
Routines are most useful when they are narrow, event-driven, and clear about what counts as worth notifying you.
You do not need to start from a blank routine editor. After a chat handles a workflow correctly, tell the companion:
```text theme={null}
Do this workflow every Tuesday morning.
```
Ask it to collect the missing details before it creates the routine.
## Start with the trigger
Choose the trigger that matches the job:
* Daily routine for morning briefings
* Interval routine for frequent checks
* Cron expression for advanced schedules
* App trigger for events such as new email
## Combine related instructions
If multiple actions happen from the same trigger and share the same context, put them in one routine prompt.
Good:
```text theme={null}
When new emails arrive, identify receipts, extract amount and vendor,
save attachments to the accounting folder, and draft a note to my bookkeeper.
```
Less efficient:
```text theme={null}
Create one routine for identifying receipts and another routine for saving receipts.
```
Each routine execution runs its own AI call, so related instructions are often cheaper and easier to review in one routine.
## Define notification rules
Tell the routine when to notify you.
```text theme={null}
Notify me only when a customer email is urgent, a payment looks overdue,
or a reply needs my approval. If nothing needs action, delete the automatic chat.
```
## Keep routines scoped
Avoid routines that inspect every connected app without a reason. Scope by account, folder, label, channel, project, or keyword when possible.
## Use approval gates
For routines that can send messages or update systems, ask Strawberry to draft and notify first.
```text theme={null}
Draft the reply and notify me. Do not send until I approve.
```
## Review run history
Open `strawberry://routines/history` or a routine detail page to review run history. Use it to reduce noise, catch failures, and tune prompts.
If a routine improves after tuning, ask the companion to update the routine prompt or create a skill that captures the refined workflow.
## Good starter routines
* Daily calendar, email, and Slack briefing
* Weekly pipeline risk check
* Invoice and receipt forwarding
* Meeting follow-up drafting
* New lead deduplication and enrichment
* Competitor or target account monitoring
# Security and control best practices
Source: https://docs.strawberrybrowser.com/best-practices/security-and-control
Use Strawberry safely with permissions, app access, shared companions, public links, account deletion, and human review.
Strawberry is powerful because companions can use real context and tools. Use that power with clear boundaries.
## Start read-only
For a new workflow, start by allowing reading and drafting. Add write actions only after you trust the prompt and output.
Good default:
```text theme={null}
Read the relevant context and draft the update. Do not send, delete,
purchase, invite, or update records without asking me first.
```
## Use permission settings
Review:
* `strawberry://settings/ai-permissions`
* `strawberry://settings/integrations`
* Per-integration tool permissions
* Folder access prompts
* Routine permissions
## Be careful with always-allow
Only use **Always allow** for low-risk actions you understand. Avoid always-allow permissions for tools that send messages, change records, delete data, invite users, or spend money.
## Treat shared companions as editable
Companion sharing currently grants edit access. Recipients can update settings, memories, and skills until you stop sharing.
Do not put sensitive files or private instructions into a companion you plan to share broadly.
## Public file links
Public file links are unlisted snapshots, not private access-controlled shares. Anyone with the link can view the published snapshot until you revoke it.
## Destructive actions
Review destructive actions carefully:
* Account deletion
* Team deletion
* Clearing cookies and site data
* Disconnecting app accounts
* Removing members
* Revoking shared access
* Deleting files
## Human review checklist
Before approving an important action, check:
* Which account or profile is involved
* Which external app will be changed
* Whether the output cites sources
* Whether the companion is acting on current data
* Whether the action can be undone
# Personal billing
Source: https://docs.strawberrybrowser.com/billing/personal-billing
View plan and usage, upgrade, downgrade, switch billing interval, cancel, reactivate, buy top-ups, and open receipts.
Personal billing is managed at `strawberry://settings/pricing`.
The account overview at `strawberry://settings/account` shows current plan name and credit usage.
## Choose a credit account
If you have both personal and team credits, choose which balance new AI work uses:
1. Open the profile menu in the top-right corner.
2. Open **Credit account**.
3. Select **Personal credits** or a team credit account.
On the web, open **Account** -> **Billing & usage** -> **Credit account**.
Switching does not transfer or combine balances. Plan changes, payment methods, receipts, and invoices remain under billing settings.
## View current plan and usage
1. Open `strawberry://settings/account`.
2. Check plan name, renewal date, and credit usage in **Current plan**.
3. Open `strawberry://settings/pricing` for full plan details and receipts.
## Upgrade, downgrade, or switch interval
1. Open `strawberry://settings/pricing`.
2. Toggle **Monthly** or **Yearly**.
3. Click the target plan button.
4. Confirm when prompted.
Notes:
* Upgrades apply immediately with prorated billing.
* Some downgrades are scheduled for period end and shown as **Downgrade scheduled**.
* If cancellation is scheduled, use **Don't cancel** to reactivate before period end.
## Cancel subscription
1. Open `strawberry://settings/pricing`.
2. Scroll to **Receipts & invoices**.
3. Click **Open billing portal**.
4. In the Stripe billing portal, cancel the subscription.
Your plan stays active until the end of the current billing period.
To undo a pending cancellation, open `strawberry://settings/account` and click **Don't cancel** in the cancellation banner.
## Open billing portal
1. Open `strawberry://settings/pricing`.
2. In **Receipts & invoices**, click **Open billing portal**.
3. Use Stripe customer portal for subscription, payment method, and invoice management.
## View receipts
Open `strawberry://settings/pricing`, then use **Open billing portal** in **Receipts & invoices** to view past invoices in Stripe.
# Pricing plans
Source: https://docs.strawberrybrowser.com/billing/pricing-plans
Compare Strawberry Free, Intern, Part-time, Full-time, and Team plans, including included credits and overage basics.
Strawberry plans combine a monthly subscription with included AI credits. Browsing without companion help does not consume credits.
Prices and credits are based on the committed pricing page in this repo. Always check
`strawberrybrowser.com/pricing` or `strawberry://settings/pricing` for the current live catalog
before making a purchase decision.
## Personal plans
| Plan | Monthly price | Included credits | Intended use |
| -------------- | ------------: | ---------------: | ------------------------------------------------ |
| Free plan | \$0/month | 2,000/month | Discover what Strawberry can automate |
| Intern plan | \$20/month | 8,000/month | Experience what AI can do for your work |
| Part-time plan | \$100/month | 30,000/month | Delegate 15-20 hours of work per week |
| Full-time plan | \$250/month | 75,000/month | Automate 40+ hours of complex workflows per week |
Annual billing offers two months free in the current marketing copy.
## Team plan
Team plan pricing is custom. It supports:
* Mixed Free, Intern, Part-time, and Full-time seats
* Free-tier members upgraded as they find value
* Unified organization billing
* Admin controls and spend limits
* Overage billed at \$10 per 1,000 credits
* Dedicated onboarding and support
## Overage and top-ups
Personal plans can buy top-up credits. Team plans can use team overage when enabled by the owner or admins.
Included monthly credits reset with the billing period. Top-up credits do not expire at month end and are used after included monthly credits run out.
## Choosing a plan
* Start with Free if you are exploring.
* Choose Intern if you want regular AI work but small scope.
* Choose Part-time if Strawberry will run weekly research, outreach, recruiting, or operations workflows.
* Choose Full-time if you rely on Strawberry for broad, frequent, multi-step work.
* Choose Team when multiple people need shared billing, team files, seat management, and spend controls.
# Team shared files
Source: https://docs.strawberrybrowser.com/billing/team-shared-files
Use the shared team workspace that syncs files across members and gives companions team-visible context.
When you create or join a team, Strawberry sets up a shared team workspace that syncs files across team members.
The team workspace appears as a folder named after your team in your local Strawberry files. Strawberry shows the exact path in the team workspace and companion filesystem context.
## What team shared files are for
Use team shared files as a shared company brain:
* Research folders
* Handoff notes
* Team docs
* Reusable instructions
* Customer context
* Sales collateral
* Recruiting process docs
* Reports and artifacts companions should reuse
## Access model
* Team members can read and write files in the shared workspace.
* File changes sync automatically through the cloud.
* The team workspace is separate from personal profile workspaces.
* Personal files in `~/Strawberry/{YourProfile}/` remain private to that profile.
## Accessing team files as a companion
Companions should use the concrete team workspace path shown in their filesystem context.
File tools and bash should use the absolute path shown in the filesystem context.
Do not assume `/team-{teamname}/` or `$TEAM_DIR` exists unless the filesystem context explicitly lists it.
## Best practices
* Put team-wide stable knowledge in team workspace.
* Put personal preferences and private files in your own workspace.
* Avoid storing secrets in shared files.
* Keep folder names clear enough for humans and companions.
* Ask companions to cite which team files they used in important outputs.
# Teams and organizations
Source: https://docs.strawberrybrowser.com/billing/teams
Create a team, invite members, manage roles, change seat plans, add a card, set spend limits, and understand team billing.
Team settings live at `strawberry://settings/team`.
The **Your Team** tab is always visible in the settings sidebar. If you have not created or joined a team, it shows the team creation form. After you create or join a team, it shows team management controls.
## Create a team
1. Open `strawberry://settings/team`.
2. Enter a team name.
3. Add members if desired.
4. Choose each member role, such as `member` or `admin`.
5. Click **Create team**.
## Invite members
1. Open `strawberry://settings/team`.
2. Click **Invite**.
3. Enter email and role.
4. Send the invitation.
5. Review pending invites in the members table.
Invite emails include a join link. New users should sign up with the invited email address before accepting.
You can also copy invite links from pending invites at `strawberry://team/invite/`.
## Roles
* **Owner**: full control over billing, subscription, danger zone, and member operations.
* **Admin**: member management, role changes, spend limits, and team rename. No billing, subscription, or delete-team access.
* **Member**: read-only team view and can leave the team.
Admins cannot change their own role or remove themselves. Spending limits can be edited for members including self.
## Seat plans
1. Open `strawberry://settings/team`.
2. Use the members table.
3. Change role from the role dropdown.
4. Change seat plan from the plan dropdown.
5. Confirm the seat change.
Paid seat changes require a payment card on file. Seat upgrades bill immediately with proration. Seat downgrades are deferred to period end.
## Team billing
1. Open `strawberry://settings/team`.
2. Add a card if prompted.
3. Use **Manage team subscription** as the owner for billing portal access.
Enterprise teams are billed by contract invoice instead of self-serve card setup. If your team has an enterprise contract, the team billing section shows the contract and shared credit pool state instead of the no-card prompt.
When you accept a team invite, Strawberry selects the team credit account. To compare balances or switch back to personal credits, open the profile menu -> **Credit account**. On the web, open **Account** -> **Billing & usage** -> **Credit account**.
Switching credit accounts changes which balance new AI work uses. It does not move or combine personal and team credits.
Personal billing and receipts remain at `strawberry://settings/pricing`.
## Overage spend limit
Overage credits are used when a team member exceeds included monthly credits. They are billed at \$10 per 1,000 credits.
By default, new teams have a \$0 overage limit, which means no overage spending is allowed.
Admins can increase the team-wide limit from `strawberry://settings/team`. Per-member overage limits can be set from the members table.
When the cap is reached, members who would otherwise use team overage are blocked. Members still inside included credits continue to work normally. Members with personal top-up credits keep using those.
## Ownership and exit
* Billing ownership transfer is admin-only. Contact support.
* Non-owners can use **Leave Team**.
* Owners can use **Delete Team** in **Danger Zone**.
# Top-ups and rate limits
Source: https://docs.strawberrybrowser.com/billing/top-ups-rate-limits
Buy top-up credits, understand when they are consumed, and distinguish plan credits from short-term rate-limit windows.
Top-up credits are prepaid extra credits. Personal top-ups belong to your personal credit account. Team credit purchases belong to the selected team credit account and follow that team's access rules.
## Buy top-up credits
1. Open `strawberry://settings/account`.
2. Click **Buy Top-Ups**.
3. Choose quantity with the plus and minus buttons.
4. Click **Add credits**.
5. Confirm the purchase.
Credits are added after successful payment.
You can also buy top-up credits from the web account billing page.
If you have more than one credit account, check **Credit account** before purchasing so the credits are added to the intended balance. Switching accounts later does not move existing credits.
## Automatic top-ups
Automatic top-ups add prepaid credits when your personal balance drops below a threshold you choose.
To configure automatic top-ups:
1. Open `strawberry://settings/pricing` or the web account billing page.
2. Find **Automatic top-ups**.
3. Turn the setting on.
4. Choose the credit threshold, the amount to add, and a monthly spending limit.
5. Confirm the payment method and save changes.
Automatic top-ups use your saved payment method. If the card is declined or no payment method is available, Strawberry turns automatic top-ups off and shows the reason in billing settings.
## When top-ups are used
Top-up credits are used after your plan's included monthly credits run out.
Top-up credits do not expire at month end.
## Plan credits versus rate limits
Plan credits are your included monthly usage.
Rate-limit windows are shorter-term controls that can appear during intensive use. A rate-limit window can temporarily block or slow additional work even if you still have monthly credits.
In chat, open the content panel to see credits used by the current chat, account credits left, and any active rate-limit window.
## How to reduce usage
* Ask for a small sample first.
* Scope the number of rows, companies, pages, or candidates.
* Ask for a plan before execution.
* Reuse memory and skills instead of repeating long context.
* Use connected apps and files directly instead of pasting huge text blocks.
* Stop or steer a chat if it is solving the wrong task.
## Team overage
Team overage is separate from personal top-ups. Team overage credits are billed at \$10 per 1,000 credits when enabled and when members exceed included credits.
# Strawberry compared with Chrome
Source: https://docs.strawberrybrowser.com/browser/chrome-comparison
Compare Strawberry with Chrome for normal browsing, AI assistance, agents, connected apps, memory, routines, privacy, and migration.
Strawberry keeps the browser fundamentals users expect from Chrome-style browsers, then adds AI-native workflows directly into the browser.
## What feels familiar
Both Strawberry and Chrome support everyday browser work:
* Tabs and windows
* Address bar search
* Bookmarks
* Downloads
* Saved passwords
* History
* Profiles
* Extensions from the Chrome Web Store, subject to compatibility
* Default browser settings
If you know how to use Chrome, the basic Strawberry browser surface should feel familiar.
## What Strawberry adds
| Area | Chrome | Strawberry |
| -------------- | -------------------------------------------------------- | ------------------------------------------------------------- |
| AI context | Usually requires copying content into a separate AI tool | Companions can use browser, tab, file, and app context |
| Agent work | Not a core browser workflow | Companions can run multi-step tasks and show work traces |
| Connected apps | Browser extensions and web apps | Profile integrations that companions can use with permissions |
| Memory | Site data and browser history | Companion and shared memory for durable work context |
| Routines | External automation tools | Built-in scheduled and event-triggered companion routines |
| Transcription | Usually separate apps or extensions | Built-in voice dictation and meeting transcription |
| Team workspace | Shared via external file tools | Team synced files available to companions and teammates |
## When to use Strawberry instead of Chrome
Use Strawberry when the work benefits from context, delegation, or repetition:
* Research across many sources
* Extracting structured data from websites
* Preparing for meetings from calendar, email, web, and CRM context
* Creating reports or spreadsheets from browsing work
* Running scheduled checks or inbox workflows
* Using memory and skills to make repeated tasks more consistent
## When Chrome may still be enough
Chrome may be enough when you only need passive browsing, a specific unsupported extension, or an existing company policy that requires Chrome.
## Migration path
You do not need to switch everything at once. Start with one Strawberry profile, import bookmarks and passwords, connect one or two apps, and run a few workflows. After you trust the setup, make Strawberry your default browser at `strawberry://settings/default-browser`.
## Benchmark context
The Strawberry marketing site includes a browser benchmark page comparing Strawberry with other AI browsers on real-world agent workflows. Treat benchmarks as directional, then validate Strawberry on your own tasks.
# Downloads
Source: https://docs.strawberrybrowser.com/browser/downloads
Change download location, control save prompts, and open the downloads history page in Strawberry.
Open download settings at `strawberry://settings/downloads`.
## Change download location
1. Open `strawberry://settings/downloads`.
2. Open **Download location**.
3. Click **Change** to choose a folder.
4. Click **Reset** to return to the default Downloads folder.
## Ask where to save each file
1. Open `strawberry://settings/downloads`.
2. Toggle **Ask where to save each file before downloading**.
When enabled, Strawberry shows a save dialog for each download from web tabs.
Agent-controlled downloads keep the streamlined behavior and may bypass save-location prompts.
## View download history
Click **View downloads** or open `strawberry://downloads`.
Use the downloads page to review and manage downloaded files.
## Tips
* If you delegate download-heavy work to a companion, choose a folder that is easy to find later.
* For generated reports or artifacts, use the file preview and share controls in chat when available.
* If a file appears missing, check both the configured download folder and the chat or session files where the companion worked.
# Extensions
Source: https://docs.strawberrybrowser.com/browser/extensions
Install, manage, search, remove, and review permissions for browser extensions in Strawberry.
Open extension settings at `strawberry://settings/extensions`.
Strawberry can install extensions from the Chrome Web Store. Extensions are new in Strawberry, so extensions outside the curated compatibility set may show a note during installation. Use the feedback form to report issues.
## Manage extensions
1. Open `strawberry://settings/extensions`.
2. Search installed extensions.
3. Click **Add more extensions** to open the extension store route.
4. Open per-extension **Permissions** to review or revoke optional permissions.
5. Delete an extension from the extension list when you no longer need it.
## Installing extensions
* Extensions can be installed from the Chrome Web Store.
* Extensions outside Strawberry's curated list show a note during installation because extensions are new in Strawberry. Use the feedback form to report issues.
* Extensions known to be incompatible may be blocked.
## Permission notes
Required permissions are informational and cannot be revoked. Optional permissions and optional origins can be revoked or cleared.
For AI tool permissions, use `strawberry://settings/integrations` or `strawberry://settings/ai-permissions`. Browser extension permissions and companion app-tool permissions are separate controls.
## Best practices
* Install only extensions you trust.
* Prefer the few extensions you actually use.
* Review optional origins before granting broad website access.
* Remove extensions that duplicate built-in Strawberry AI workflows.
# Import from other browsers
Source: https://docs.strawberrybrowser.com/browser/import-from-other-browsers
Move bookmarks, passwords, history, cookies, and tabs from Chrome, Safari, Firefox, Arc, and other browser profiles into Strawberry.
Use browser import when you want Strawberry to feel useful immediately with your existing bookmarks, saved credentials, browsing history, cookies, and open tabs.
## Open import
1. Open `strawberry://settings/profiles`.
2. Find **Import from another browser**.
3. Choose the source browser and source profile.
4. Pick the data types to import.
5. Start the import and review the result summary.
## Supported data types
Depending on source browser, operating system, and local profile availability, Strawberry can import:
* Passwords
* Bookmarks
* History
* Cookies
* Open tabs
## Supported sources
The codebase includes migration strategies for:
* Chrome-family browser profiles
* Safari
* Firefox
* Zen
* Arc
Arc migration includes Arc-specific bookmark and Space handling. Zen migration keeps Essentials as pinned tabs and imports Pins into bookmark-bar folders by Space. Chrome-family imports can include current tabs when local browser data is available.
## Password import notes
Password import can require access to your operating system keychain or secure storage. If Strawberry cannot access the source password store, it may skip passwords and import other selected data types.
## Cookie import notes
Cookie import can help keep you signed in, but it depends on source browser encryption and session compatibility. Some sites may still require sign-in after migration.
## Best practices
* Close the source browser before importing if the profile database is locked.
* Import bookmarks and passwords first if you want a low-risk migration.
* Import cookies and tabs when you want to continue a browsing session.
* Keep your old browser installed until you verify the Strawberry import result.
## Troubleshooting
If an import fails or imports fewer items than expected:
1. Confirm the source browser profile exists locally.
2. Close the source browser and retry.
3. Try importing one data type at a time.
4. Check whether the source browser requires OS-level permission for passwords or cookies.
5. Report an issue from the Strawberry app menu if the problem persists.
# Privacy and data controls
Source: https://docs.strawberrybrowser.com/browser/privacy-and-data
Manage ad blocking, browsing data, site permissions, AI permissions, link safety, account deletion, and local reset.
Open privacy settings at `strawberry://settings/privacy`.
## Ad blocker
Toggle **Block ads and trackers** at `strawberry://settings/privacy`.
## Clear browsing data
Use the correct cleanup action for the outcome you want:
* **Clear Cache** clears temporary browser cache data. Cookies, local storage, IndexedDB, and saved site data are kept.
* **Clear Cookies and Site Data** removes cookies, local storage, IndexedDB, service workers, and site caches. This can sign you out of websites and remove site preferences.
* From site settings, **Clear site data** removes that site's cookies, local storage, IndexedDB, WebSQL, service workers, and cache storage.
* From site settings, **Clear cache** clears that site's cache storage and Strawberry website metadata cache only.
For chat images, large chats, and app storage, use `strawberry://settings/storage`.
## Report issue logs
Use **Strawberry** -> **Report Issue** from the application menu to send application logs to the Strawberry team. The message field is optional.
Submitting shares your local `app.log` with Strawberry support so they can diagnose issues.
## Website pop-ups and device permissions
Privacy settings and site settings control site-level behavior such as pop-ups, new tabs, camera, microphone, and other device permissions.
## AI permissions
AI action permissions live at `strawberry://settings/ai-permissions` and per integration at `strawberry://settings/integrations`.
Use AI permissions to control whether companions must ask before actions, can always perform specific actions, or cannot use an action at all.
## Account deletion
Account deletion starts from `strawberry://settings/account` under **Account Actions**.
Account deletion is immediate and irreversible. Clearing browser data or resetting this computer
is not the same as deleting your Strawberry account.
## Chat links
Strawberry has link safety controls for chat markdown links and chat navigation. Treat links from generated content like any other untrusted link, especially when they lead to sign-in, payment, or download pages.
# Profiles and appearance
Source: https://docs.strawberrybrowser.com/browser/profiles-and-appearance
Manage browser profiles, themes, colors, search engine, default browser, bookmarks, and saved passwords.
Profiles let you separate browsing contexts. A profile can have its own color, browsing data, workspace, and many profile-specific app connections.
## Browser profiles
Open `strawberry://settings/profiles`.
You can:
1. Rename the current profile.
2. Change the profile color.
3. Switch profiles.
4. Create a new profile.
5. Import from another browser.
Use separate profiles when you want clear boundaries between work, personal browsing, testing, or different companies.
## Theme and UI
Open `strawberry://settings/theme`.
You can:
* Choose **Dark mode**, **Light mode**, or **System**.
* Set the profile color.
* Toggle **Show color as tab background**.
* Choose tabs at top, tabs in sidebar, or activity sidebar.
* Toggle **Auto Picture-in-Picture for YouTube** to control whether a playing YouTube video moves into a floating mini player when you switch tabs.
## Search engine
Open `strawberry://settings/search-engine`.
Select your preferred search engine and click **Set as default**.
## Default browser
Open `strawberry://settings/default-browser`.
Click **Make default** if you want links from other apps to open in Strawberry.
## Bookmarks and passwords
* Bookmarks: `strawberry://settings/bookmarks`
* Passwords: `strawberry://settings/password`
Saved passwords are local browser data. Strawberry's privacy copy states that passwords are not exposed to Strawberry or LLM providers.
# Tabs and sidebar
Source: https://docs.strawberrybrowser.com/browser/tabs-and-sidebar
Use Strawberry tabs, chat sidebar, vertical tabs, activity sidebar, Universal Search, bookmarks, and Picture-in-Picture.
Strawberry supports normal browser tab workflows, plus AI-aware sidebars that help you move between pages, chats, and companion work.
## Tab layouts
Open `strawberry://settings/theme` to choose a tab layout:
* **Tabs at top**: a familiar horizontal tab bar.
* **Tabs in sidebar**: vertical tabs with manual ordering.
* **Activity sidebar**: tabs ordered by recent activity, with a search row that opens Universal Search for tabs and chats.
## Chat sidebar
Press `Cmd/Ctrl + E` to toggle the chat sidebar. Use it to start chats, revisit previous sessions, check running routines, and open companion work.
Routines can appear in the sidebar when they are scheduled, running, listening, or need your input.
## Universal Search
Press `Cmd + Shift + A` on macOS or `Ctrl + Shift + A` on Windows.
Universal Search helps you find:
* Open tabs
* Recent tabs
* Chats
* Sidebar history
Use chips to filter to tabs or chats. Click an active chip again to return to all results.
## Bookmarks
Open bookmark settings at `strawberry://settings/bookmarks`.
You can:
* Show the bookmarks bar always, only on the new tab page, or never.
* Search and manage bookmark folders.
* Right-click a tab to add or move it to a bookmark folder.
* Use the bookmark manager shortcut: `Cmd + Option + B` on macOS or `Ctrl + Shift + O` on Windows.
## Picture-in-Picture
When **Auto Picture-in-Picture for YouTube** is on, Strawberry moves a playing YouTube video into a floating mini player when you switch to another tab. Switching to a different window does not trigger it.
To turn it off, go to `strawberry://settings/theme` -> **Picture-in-Picture** and switch off **Auto Picture-in-Picture for YouTube**. The setting is on by default and syncs across your devices.
## Best practices
* Use activity sidebar if you jump between many tabs and want recency to drive navigation.
* Use Universal Search instead of scanning long tab lists.
* Keep work-related tabs grouped by profile so companions and integrations stay scoped to the right context.
# Welcome to Strawberry
Source: https://docs.strawberrybrowser.com/index
Start here to learn what Strawberry Browser is, how it works, and where to find the right docs.
Strawberry is a browser built for AI work. It keeps the browser you expect, including tabs, profiles, bookmarks, downloads, passwords, extensions, and history, then adds companions that can read pages, use connected apps, remember useful context, and run multi-step work with you.
Use these docs for two kinds of questions:
* **How do I use the app?** Find routes, settings, shortcuts, billing flows, permissions, and troubleshooting steps.
* **How do I get better results?** Learn how to prompt companions, create routines, use memory and skills, and give Strawberry enough context to do useful work.
## Where to start
* New to Strawberry: read [What Strawberry is](/introduction/what-is-strawberry), then [Quickstart](/introduction/quickstart).
* Moving from another browser: read [Import from other browsers](/browser/import-from-other-browsers) and [Strawberry compared with Chrome](/browser/chrome-comparison).
* Using AI features: read [Companions](/ai/companions), [Chat](/ai/chat), and [Agent runs](/ai/agent-runs).
* Managing usage: read [Credits and usage](/ai/credits-usage), [Pricing plans](/billing/pricing-plans), and [Personal billing](/billing/personal-billing).
* Building repeatable workflows: read [Routines](/knowledge/routines), [Skills](/knowledge/skills), and [Prompting best practices](/best-practices/prompting).
## Important Strawberry routes
You can paste Strawberry routes into the address bar:
* `strawberry://newtab` starts a new chat, lets you pick a companion, and shows suggested use cases.
* `strawberry://settings` opens settings.
* `strawberry://settings/account` shows account details, current plan, credit usage, invite codes, and account actions.
* `strawberry://settings/pricing` shows plans, billing, receipts, and subscription controls.
* `strawberry://settings/team` manages team members, roles, seat plans, shared files, and overage limits.
* `strawberry://knowledge` opens use case templates, memory, reports, skills, and transcriptions.
* `strawberry://routines` opens routine management.
If you are asking a companion about Strawberry itself, ask it to check `strawberry-docs` before
answering. Strawberry keeps product help docs in the shared companion filesystem so companions can
answer route and settings questions from the same source users read.
## Documentation status
This docs app starts with broad coverage and a stable navigation structure. Some pages intentionally summarize areas that will grow later, such as deeper integration-specific guides, visual walkthroughs, and screenshots.
# MCP and custom integrations
Source: https://docs.strawberrybrowser.com/integrations/mcp-custom-integrations
Add remote HTTP MCP servers, local command MCP servers, API-key integrations, and environment variables safely.
Custom MCP integrations let Strawberry connect to tools that are not built into the app.
Open `strawberry://settings/integrations`, then use **Add MCP**.
## MCP server types
### HTTP MCP servers
HTTP MCP servers run remotely or locally and communicate over HTTP, SSE, or Streamable HTTP.
You provide:
* Name
* Server URL
* Optional API key
* Optional OAuth sign-in when supported
### Command MCP servers
Command MCP servers run as local subprocesses that communicate over stdin and stdout.
You provide:
* Name
* Full command line
* Optional environment variables
Example command shape:
```bash theme={null}
npx -y @modelcontextprotocol/server-filesystem /path/to/folder
```
## Environment variables
Command MCPs can receive environment variables. Use them for API keys or configuration the server needs. Values are encrypted at rest.
## Security
Only add MCP servers you trust.
Command MCPs run as local processes with your system permissions. Strawberry does not verify
third-party MCP servers for you.
## Best practices
* Prefer official vendor MCP servers when available.
* Read the server documentation before adding it.
* Scope local filesystem MCPs to the narrowest folder that solves the task.
* Avoid putting long-lived secrets into untrusted tools.
* Disable or remove custom MCPs when a project ends.
# Connected apps overview
Source: https://docs.strawberrybrowser.com/integrations/overview
Connect Google, Microsoft, Slack, Notion, CRM, ATS, MCP, and API-key tools so companions can work with real context.
Connected apps let Strawberry companions use your real work systems with your permission.
Open integrations at `strawberry://settings/integrations`.
You can also manage apps from companion settings by opening a companion and selecting the **Apps** tab.
## Profile-specific apps
Most apps are profile-specific. Each profile manages its own connections independently. Once connected, every companion in that profile can use them according to permissions.
Examples include:
* Gmail
* Google Calendar
* Google Sheets
* Google Drive
* Google Docs
* Outlook
* OneDrive
* Slack
* Notion
* Ashby
* PandaDoc
* Plausible
* MCP and API-key integrations
## Account-wide apps
Some apps are shared across all profiles:
* HubSpot
* Airtable
* GitHub
* Salesforce
## Connect or disconnect an app
1. Open `strawberry://settings/integrations`.
2. Open the integration detail page.
3. Click **Connect** or **Add Account**.
4. Complete OAuth or enter the requested token.
5. Use **Disconnect** to remove an account connection.
API-key and token integrations use the same page, but prompt for provider credentials instead of opening OAuth.
## What companions can do
Each app exposes specific tools. For example, an email app might support reading messages and drafting replies, while a CRM might support reading records and writing updates.
Tool permissions control whether companions must ask before using each action.
## Best practices
* Connect only the apps needed for your workflows.
* Start with read-heavy workflows before enabling write-heavy actions.
* Review app permissions after adding a new routine.
* Disconnect apps you no longer use.
* Use companion-specific prompts to limit which apps a companion should prefer.
# Integration permissions
Source: https://docs.strawberrybrowser.com/integrations/permissions
Configure per-app tool permissions so companions ask, always allow, or cannot use specific connected app actions.
Integration permissions control what companions can do with connected apps.
Use them together with global AI permissions at `strawberry://settings/ai-permissions`.
## Configure tool permissions
1. Open `strawberry://settings/integrations`.
2. Open an integration's detail page.
3. Find **Permissions**.
4. Set each action to one of:
* **Ask every time**
* **Always allow**
* **Disable action**
## Choosing a permission level
Use **Ask every time** for actions that:
* Send messages
* Create, update, or delete records
* Spend money
* Change billing state
* Affect customers, candidates, or teammates
* Access sensitive data
Use **Always allow** for low-risk, frequent actions that are needed for normal work, such as reading non-sensitive lists or checking routine context.
Use **Disable action** when a companion should never use that capability.
## Permanent versus chat-specific permissions
Permanent permissions apply across sessions and are managed in integration settings.
Chat-specific permissions apply only to the current chat and clear when the chat ends.
## Routine considerations
Routines can run while you are not actively watching. Review permissions carefully before giving a routine access to write actions.
For routines, it is often safer to let Strawberry read and draft, then notify you for approval before sending or mutating external systems.
## Audit checklist
Review permissions when:
* You connect a new app.
* You create a routine.
* You share a companion.
* A team member changes roles.
* Your workflow begins touching customer, payment, hiring, or production systems.
# Account basics
Source: https://docs.strawberrybrowser.com/introduction/accounts
Manage your email, sign out, delete your account, reset local data, and redeem invite codes.
Account settings live at `strawberry://settings/account`.
Use this page for identity, plan status, current usage, invite code actions, sign-out, account deletion, and resetting local Strawberry data on the current computer.
## Update your email
1. Open `strawberry://settings/account`.
2. In **Account Details**, click the pencil icon next to **Email**.
3. Enter the new email address.
4. Request a verification code.
5. Enter the 6-digit code.
6. Confirm the update.
After a successful email update, Strawberry signs you out. Sign in again with the updated email.
## Sign out
1. Open `strawberry://settings/account`.
2. Scroll to **Account Actions**.
3. Click **Sign out**.
## Delete your account
1. Open `strawberry://settings/account`.
2. In **Account Actions**, click **Delete account**.
3. Read the deletion warning.
4. Click **Send Code**.
5. Enter the 6-digit code sent to your account email.
6. Type the account email if prompted.
7. Confirm deletion.
Account deletion is immediate and irreversible. Do not start deletion unless you are sure you want
to permanently delete the account and associated data.
## Reset this computer
Use local reset when you want to remove Strawberry data from the current machine without deleting the account itself.
Common reasons:
* You are handing a computer to someone else.
* Local browser data is corrupted.
* You want a clean local profile setup.
Account deletion and local reset are different. Account deletion removes server-side account data. Local reset removes data on the current computer.
## Redeem an invite code
1. Open `strawberry://settings/account`.
2. Find the invite or referral section.
3. Enter the code.
4. Confirm redemption.
Invite and referral bonuses may grant credits depending on the current program.
## Share your invite link
Open `strawberry://settings/account` and use the invite section to copy your invite link when available.
# Glossary
Source: https://docs.strawberrybrowser.com/introduction/glossary
Definitions for common Strawberry terms such as companions, routines, credits, memory, skills, plans, profiles, and work traces.
## Companion
An AI assistant profile in Strawberry. A companion can chat with you, use tools, remember context, hold files, run routines, and have companion-specific skills.
## Chat
A conversation with a companion. Chats can include attached files, selected tabs, queued follow-ups, work traces, generated files, and sub-agent activity.
## Agent run
A companion task that uses tools or takes multi-step actions, such as reading pages, searching, writing files, using connected apps, or spawning sub-agents.
## Sub-agent
A focused helper agent spawned by a main companion to work on a scoped task. Sub-agents can have their own `PLAN.md` and work trace.
## Routine
An automation that runs on a schedule or app event. Routines are managed per companion and on the full `strawberry://routines` page.
## Skill
Reusable instructions for a kind of work. Skills can be global to your profile or specific to one companion.
## Memory
Stable information Strawberry saves so companions can use it later. Memory can include preferences, company context, workflow notes, and other durable facts.
## Knowledge
The `strawberry://knowledge` page that gathers use case templates, memory, reports, skills, and transcriptions.
## Credits
The usage unit for AI work in Strawberry. Browsing without companion help does not consume credits. Companion replies, agent runs, web research, app actions, and transcription-related AI work can consume credits.
## Credit account
A separate personal or team credit balance. One credit account is active at a time, and new AI work uses that account. Switching credit accounts does not transfer or combine their balances. "Billing account" is the internal term for the underlying billing record.
## Top-up credits
Prepaid extra credits. Top-up credits are used after included monthly credits run out and do not expire at month end.
## Profile
A browser profile with its own browsing data and many profile-specific settings, such as integrations and workspace files.
## Team workspace
A shared synced folder created for team members. Strawberry shows the exact local path in the team workspace and companion filesystem context.
## Work trace
The visible record of what a companion or sub-agent did during a task, including searches, file operations, app tool calls, browser actions, questions, and progress.
# Keyboard shortcuts
Source: https://docs.strawberrybrowser.com/introduction/keyboard-shortcuts
Common Strawberry shortcuts for tabs, windows, chat, search, bookmarks, downloads, and settings.
Most browser shortcuts match familiar Chrome-style shortcuts. Use `Cmd` on macOS and `Ctrl` on Windows unless a shortcut says otherwise.
## Core shortcuts
* Settings: `Cmd/Ctrl + ,`
* New tab: `Cmd/Ctrl + T`
* New window: `Cmd/Ctrl + N`
* New incognito window: `Shift + Cmd/Ctrl + N`
* Reopen closed tab: `Cmd/Ctrl + Shift + T`
* Open address bar: `Cmd/Ctrl + L`
* Close tab: `Cmd/Ctrl + W`
* Close window: `Cmd/Ctrl + Shift + W`
* New chat: `Cmd/Ctrl + Shift + E`
* Find: `Cmd/Ctrl + F`
* Copy tab address: `Cmd/Ctrl + Shift + C`
* Add or remove bookmark: `Cmd/Ctrl + D`
* Print: `Cmd/Ctrl + Shift + P`
## Sidebar and tabs
* Toggle chat sidebar: `Cmd/Ctrl + E`
* Show tabs in sidebar: `Cmd/Ctrl + Shift + S`
* Toggle tab sidebar when vertical tabs are enabled: `Cmd/Ctrl + S`
* Switch to the previous recent tab: `Ctrl + Tab`
* Cycle backward in the recent-tab switcher: `Ctrl + Shift + Tab`
* Universal Search for tabs and chats: `Cmd + Shift + A` on macOS or `Ctrl + Shift + A` on Windows
## Bookmarks and downloads
* Bookmark manager: `Cmd + Option + B` on macOS or `Ctrl + Shift + O` on Windows
* Downloads: `Cmd + Shift + J` on macOS or `Ctrl + J` on Windows
## Companion switching
In chat input, `Cmd + .` cycles through companions. Use `Shift` with the shortcut to cycle backward.
## Tip
If a shortcut is not working, check whether focus is inside a web page, browser chrome, chat input, or an external window. Some shortcuts depend on the active surface.
# Quickstart
Source: https://docs.strawberrybrowser.com/introduction/quickstart
Set up Strawberry, open the main pages, start a chat, connect apps, and run your first useful workflow.
Use this quickstart to get from a fresh install to your first useful Strawberry workflow.
## 1. Install and sign in
Download Strawberry from `strawberrybrowser.com/download`, install it, and sign in. Strawberry is available for macOS and Windows.
After sign-in, open `strawberry://settings/account` to check your account email, current plan, credit usage, invite code options, and account actions.
## 2. Import browser data
Open `strawberry://settings/profiles`, then use **Import from another browser**. Strawberry supports importing from common browser profiles, including Chrome-family browsers, Safari, Firefox, and Arc depending on platform and local data availability.
Import what you need first:
* Bookmarks help you keep your browsing setup.
* History helps address bar suggestions and recall.
* Passwords reduce sign-in friction.
* Cookies and tabs can help you continue an existing browsing session when supported.
## 3. Start from the new tab page
Open `strawberry://newtab`.
You can:
* Pick a companion.
* Start a chat immediately.
* Paste or drop files into the chat input.
* Browse suggested use cases.
* Click **Discover use cases** to let Strawberry ask questions and suggest workflows.
## 4. Connect one or two apps
Open `strawberry://settings/integrations`.
Start with the apps that give Strawberry useful context:
* Gmail or Outlook for email workflows
* Google Calendar for meeting prep and scheduled meeting recording
* Google Drive, Docs, Sheets, or Notion for files and knowledge
* Slack for team updates
* HubSpot, Attio, Salesforce, Ashby, or other systems for domain-specific workflows
## 5. Try a focused prompt
Give Strawberry a concrete goal, the context it should use, and the output you want.
```text theme={null}
Help me prepare for my next sales call.
Use my calendar to find the meeting, check any recent emails with the company,
research their website and LinkedIn, and give me a concise briefing with
risks, likely pain points, and three questions to ask.
```
## 6. Review permissions and output
When a companion needs to use a connected app or take an action, Strawberry may ask for approval. Read the request, confirm what will happen, and approve only if it matches your intent.
Open the chat's content or work trace panels to review credits, sources, files, sub-agents, and progress.
## 7. Make it repeatable
If you repeat a task often, turn it into a routine or skill:
* Use a **routine** when the task should run on a schedule or app event.
* Use a **skill** when you want reusable instructions for a kind of task.
* Use **memory** when Strawberry should remember stable facts about you, your company, your preferences, or your workflow.
# Settings navigation
Source: https://docs.strawberrybrowser.com/introduction/settings-navigation
Open Strawberry settings and jump directly to account, billing, team, integrations, privacy, downloads, and other pages.
Open settings in any of these ways:
1. Press `Cmd + ,` on macOS or `Ctrl + ,` on Windows.
2. Click the profile or settings button in the top-right browser toolbar, then click **Settings**.
3. Type `strawberry://settings` in the address bar.
When opened without a subpath, Strawberry redirects to `strawberry://settings/account`.
## Account and billing
* Account overview: `strawberry://settings/account`
* Billing, plans, and receipts: `strawberry://settings/pricing`
* Team management: `strawberry://settings/team`
* Active credit account: profile menu -> **Credit account**
## AI and connected apps
* Connected apps and integrations: `strawberry://settings/integrations`
* AI permission controls: `strawberry://settings/ai-permissions`
* Meeting transcription setup and tuning: `strawberry://settings/transcription`
* Extensions: `strawberry://settings/extensions`
## Browser preferences
* Profiles: `strawberry://settings/profiles`
* Theme and UI: `strawberry://settings/theme`
* Search engine: `strawberry://settings/search-engine`
* Default browser: `strawberry://settings/default-browser`
* Bookmarks: `strawberry://settings/bookmarks`
* Passwords: `strawberry://settings/password`
* Downloads: `strawberry://settings/downloads`
## Data
* Privacy controls: `strawberry://settings/privacy`
* Storage and cleanup: `strawberry://settings/storage`
## App updates
Use the application menu for update checks and issue reporting. Some support options may vary by release.
## Quick links outside settings
* New tab: `strawberry://newtab`
* Downloads page: `strawberry://downloads`
* Knowledge page: `strawberry://knowledge`
* Routines: `strawberry://routines`
# What Strawberry is
Source: https://docs.strawberrybrowser.com/introduction/what-is-strawberry
Understand Strawberry Browser, companions, agent work, routines, memory, skills, and how they fit together.
Strawberry is a full browser with AI companions built into the browsing workflow. You can use it like a normal browser, but when you need help, a companion can read what is on screen, answer questions, operate web pages, use connected apps, create files, and continue multi-step work in the background.
The central idea is simple: your browser already contains the work context. Strawberry lets an AI use that context directly, instead of making you copy page text, screenshots, files, and instructions into a separate chatbot.
## Core concepts
### Browser
Strawberry includes browser basics such as tabs, windows, bookmarks, downloads, profiles, saved passwords, history, extensions, search engine settings, default browser settings, and import from other browsers.
### Companions
Companions are the AI profiles you chat with. Each companion can have its own instructions, memory, files, routines, skills, connected app access, and visual identity. You can create different companions for different kinds of work, such as sales, recruiting, research, operations, or personal productivity.
### Chat
Chat is where you ask questions, delegate work, attach files, reference tabs, and review outputs. Strawberry supports queued follow-ups, so you can keep giving instructions while a companion is already responding.
### Agent runs
An agent run is a more active task. The companion can navigate pages, search, read files, write files, use tools, ask for feedback, and spawn sub-agents for scoped work. Strawberry shows work traces so you can see what happened.
### Routines
Routines are scheduled or trigger-based automations. A routine can run every day, every few hours, on a cron expression, or when an app event fires, such as a new email.
### Knowledge
The Knowledge page gathers what Strawberry can use or has created for you: use case templates, memory, reports, skills, and transcriptions.
## What Strawberry is good at
Strawberry is strongest when the task involves browser context, connected app context, or repeated work:
* Researching companies, people, markets, products, and competitors
* Extracting data from websites into spreadsheets or reports
* Drafting and personalizing messages from real context
* Preparing for meetings from calendar, email, web, and CRM data
* Summarizing Slack, email, documents, and transcripts
* Building routines that monitor tools and alert you only when something matters
## What still needs your judgment
Strawberry can act, but you stay in control. Sensitive actions use permission prompts. You should review important outputs, especially when a task involves money, legal commitments, hiring decisions, external messages, deletions, or customer-facing updates.
Treat companions as capable assistants, not final authorities. Review destructive actions,
external messages, billing changes, and business-critical outputs before confirming them.
# Memory
Source: https://docs.strawberrybrowser.com/knowledge/memory
Understand Strawberry memory, shared memory, companion memory, editable memory files, and best practices for durable context.
Memory is durable context Strawberry can use later. It helps companions avoid asking the same questions repeatedly and makes future work more personal and specific.
## What memory can contain
Useful memory is stable and reusable:
* Your role, company, industry, and goals
* Product and customer context
* Writing style and tone preferences
* ICP and target account details
* Tooling and workflow preferences
* Recurring constraints, such as regions, formats, or approval rules
Avoid using memory for temporary tasks, one-off instructions, secrets, or information that will quickly become stale.
## Where memory appears
Open `strawberry://knowledge/memory`.
Memory files appear as cards. Each card opens the underlying memory file in the document viewer. Markdown files can be edited with the rich editor.
## Shared and companion memory
Strawberry supports information shared with every companion and companion-specific memory. Companion-specific memory is useful when a recruiting companion should remember different context than a sales companion.
## Editing memory
You can edit memory files directly. Good edits are short, factual, and easy for a companion to apply.
```text theme={null}
When writing outbound sales messages, keep the tone concise, direct,
and lightly personal. Avoid hype. Lead with the prospect's likely problem.
```
## Memory and privacy
Only store information you are comfortable making available to the relevant companion scope. When sharing a companion, remember that the recipient can access that companion's synced folder, including memories.
## Best practices
* Store stable context, not every chat detail.
* Use headings so memory files are easy to scan.
* Remove outdated preferences.
* Keep sensitive details out of memory unless they are necessary and scoped correctly.
* Ask a companion to summarize new durable facts before saving them.
# Knowledge page
Source: https://docs.strawberrybrowser.com/knowledge/overview
Use the Knowledge page to browse use case templates, memory, reports, skills, and transcriptions.
The Knowledge page is the app-level view of what Strawberry has learned from you and what it can offer back to you.
Open it at `strawberry://knowledge`.
## Open Knowledge
You can open Knowledge in three ways:
1. Click the **Knowledge** button in the left chat-history sidebar.
2. Use the app menu and choose **Open Knowledge Page**.
3. Type `strawberry://knowledge` in the address bar.
When opened without a subpath, Strawberry shows **Use case templates**.
## Sections
Use these direct links:
* Use case templates: `strawberry://knowledge`
* Memory: `strawberry://knowledge/memory`
* Reports: `strawberry://knowledge/reports`
* Skills: `strawberry://knowledge/skills`
* Transcriptions: `strawberry://knowledge/transcriptions`
The Knowledge page sidebar switches between these sections.
## Search
Each section has its own search box. Switching sections resets search, so a query from one section does not accidentally filter another.
## What belongs in Knowledge
* Use case templates help you start useful workflows.
* Memory stores stable facts and preferences.
* Reports collect outputs from companion tasks.
* Skills store reusable instructions.
* Transcriptions store saved meeting and audio transcripts.
## Requirements
The Knowledge page requires you to be signed in.
# Reports and files
Source: https://docs.strawberrybrowser.com/knowledge/reports-and-files
Find generated reports, shared files, companion files, workspace files, transcript files, and public file links.
Strawberry companions can create files and reports as part of their work. Files can live in a chat session, a companion folder, your workspace, or a team workspace.
## Reports
Open `strawberry://knowledge/reports`.
Reports are generated by companion tasks. Open a report to see the full output and continue the conversation that produced it.
## Files in companion settings
Open a companion's settings and go to **Files**.
The file browser can show:
* The companion's own folder
* Your workspace
* Team workspace when a local team folder exists
You can drop local files into the open folder to copy them there. If a file with the same name already exists, Strawberry saves the dropped file with a unique numbered name.
## Workspace files
Your workspace is profile-level. It can hold memory, skills, transcripts, reports, and regular files you want companions to use.
Team workspace files are shared with team members. See [Team shared files](/billing/team-shared-files).
## Public file links
You can share a synced file, folder, report, or generated HTML artifact:
1. Open the file or folder.
2. Choose **Share** or **Copy public link**.
3. Strawberry publishes a snapshot and copies a `strawberrybrowser.com/files/...` link.
Public links are unlisted snapshots. They are not private access-controlled shares. Revoke a public link from the share dialog when it should no longer load.
## Share access with people
In the share dialog, use **Invite people by email** to share access with specific people. If you are on a team, typing in the field suggests team members by name and email. Select a suggestion to fill the email, then click **Invite**.
Use the permission menu next to each person to choose viewer or editor access, or remove access when they no longer need the file.
## Send or download reports
The report share dialog also includes action chips for connected sharing apps and downloads. Reports can be downloaded as Markdown or PDF. If Slack or Gmail is connected, use the Slack or Gmail chip to open a send dialog with the report attached.
## Best practices
* Put reusable reference files in your workspace or team workspace.
* Put companion-specific instructions and skills in that companion's folder.
* Publish public links only for files you are comfortable sharing with anyone who has the URL.
* Regenerate public links when the source file changes.
# Routines
Source: https://docs.strawberrybrowser.com/knowledge/routines
Create, discover, manage, run, pause, and review Strawberry routines for scheduled and event-triggered work.
Routines are automations managed per companion and from the full Routines page at `strawberry://routines`.
The routines page has a flat list across companions, companion filters, search, detail screens, editing, and run history.
You can create routines conversationally. If a workflow should repeat, tell the companion:
```text theme={null}
Do this workflow every Tuesday morning.
```
The companion can help turn the workflow into a scheduled routine and ask for any missing trigger, account, approval, or notification details.
## Routine routes
* `/routines`: list view with a run history sparkline card
* `/routines/history`: aggregate run history across companions
* `/routines/:id`: routine detail and run history
* `/routines/:id/edit`: routine editor
* `/routines/new`: opens the routines list with the create-routine dialog
## Create a routine
1. Open `strawberry://routines`.
2. Click **New routine** to open the create-routine dialog.
3. Choose a trigger type:
* **Daily**
* **Interval**
* **Cron expression**
* App trigger, such as new email
4. If the trigger needs a connected account, select one.
5. Give the routine a name.
6. Write the instruction prompt.
7. Click **Create routine**. A routine needs at minimum a name and instructions. If anything required is missing, **Create routine** stays clickable and the dialog highlights the fields that need attention instead of being disabled.
## Create a routine from a chat
When a chat produces a workflow you want to repeat, ask Strawberry to schedule it:
```text theme={null}
Do this workflow every Tuesday morning.
Ask me any targeted questions you need to make the routine reliable.
```
Good routine-creation chats usually clarify:
* The schedule or event trigger
* Which companion should run the work
* Which connected account, folder, label, project, or source to use
* What counts as important enough to notify you
* What the routine may do automatically
* What must wait for your approval
## Discover routine ideas
If a companion has no routines yet, the empty state can show **Suggest routines**. Strawberry opens the chat sidebar over your current page, scans connected apps, and suggests personalized routines for that companion.
The new tab page can also show a **Discover routines** action that opens the same discovery flow.
## Manage routines
You can:
* Filter by companion.
* Search routines.
* Open a detail page.
* Edit a routine.
* Delete a routine.
* Pause and resume.
* Run now for scheduled routines.
* Replay last run for webhook routines when available.
* Review run history.
## How running routines appear
When a routine fires, Strawberry creates a real chat session. If the task finds nothing significant, it can delete the automatic chat. If it finds something, it can notify you and keep the session visible.
Cron routines show scheduled-work notices. Webhook routines show webhook notices with integration logos when available.
## Best practices
* Combine related actions into one routine prompt when they share the same trigger.
* Keep prompts explicit about what counts as important enough to notify you.
* Ask routines to delete quiet chats when nothing meaningful happened.
* Review run history to tune noisy routines.
# Skills
Source: https://docs.strawberrybrowser.com/knowledge/skills
Create, edit, organize, and use Strawberry skills as reusable instructions for repeated workflows.
Skills are reusable instructions. They help companions apply the same playbook each time a similar task comes up.
Use a skill when you find yourself writing the same prompt, checklist, rubric, or process repeatedly.
The easiest way to create a skill is from a chat that already went well. Tell the companion:
```text theme={null}
Create a skill for me from this workflow.
```
The companion can summarize the steps, inputs, approval gates, and output format into reusable instructions for future tasks.
## Global skills
Global skills are installed for your profile. Open them at `strawberry://knowledge/skills`.
From a skill card, you can read or edit the skill instructions in the document viewer or start a chat that uses it.
## Companion-specific skills
When you add a skill from companion settings, Strawberry creates it in that companion's own **Files -> \[companion name] -> skills** folder.
Companion-specific skills:
* Belong to that companion.
* Appear before global skills in the slash menu.
* Follow the companion when shared with another user or team.
## What to put in a skill
A useful skill includes:
* When to use it
* What inputs to ask for
* What sources to inspect
* What steps to follow
* What output format to produce
* What requires user approval
* How to verify the work
## Turn good chats into skills
When a companion does something correctly, do not make yourself remember every detail. Ask it to capture the process.
Useful follow-ups:
```text theme={null}
Create a skill for me from what we just did.
Make sure it includes the questions you asked, the sources you checked,
the approval rules, and the final output format.
```
```text theme={null}
Update the skill so next time you ask for a sample size before running
the full workflow.
```
Review the draft before saving it. A good skill should still ask targeted questions when the task depends on missing context.
## Example skill skeleton
```text theme={null}
# Skill: Competitor teardown
Use when the user asks to analyze a competitor's website, pricing,
positioning, product, or go-to-market motion.
Process:
1. Ask which competitor and what decision the user is trying to make.
2. Inspect official website pages first.
3. Capture pricing, target customer, core claims, integrations, and proof.
4. Compare findings to what you know about the user's company.
5. Return a concise battlecard with source links and confidence notes.
Ask before sending messages, signing up for products, or using paid tools.
```
## Best practices
* Keep skills focused.
* Avoid stuffing unrelated workflows into one skill.
* Include examples of good output.
* Update skills after a companion makes a useful improvement.
* Ask a companion to create or update the skill while the successful workflow is still fresh.
* Use memory for facts and skills for process.
# Transcription and meeting recording
Source: https://docs.strawberrybrowser.com/knowledge/transcription
Record meetings, transcribe voice, configure microphones, add languages and preferred terms, and browse saved transcripts.
Strawberry can transcribe your voice in chat and record meetings. Configure it at `strawberry://settings/transcription`.
## Why record meetings
Meeting transcripts help companions:
* Draft follow-up emails
* Book meetings
* Update CRMs
* Create summaries
* Recall past decisions
* Use meeting context in future work
## The record button
The microphone button in chat works as both dictation and meeting recording.
Short recordings become text in your chat input. Recordings longer than about one minute are treated as meeting transcripts.
## Online meetings
Strawberry can record online meetings on Google Meet, Zoom, and Microsoft Teams.
Recording can start from:
* Auto-detected meeting URL toasts
* Scheduled meeting notifications from Google Calendar
* The chat input record button
## In-person meetings
Open a new tab and click the record button in the chat input. Strawberry captures microphone audio and transcribes the conversation.
## During a recording
A floating pill widget shows audio level bars and controls. Hover to reveal pause and stop. Drag the widget to reposition it.
## First-time setup
macOS:
1. Enable microphone access.
2. Enable screen and system audio access for remote participants.
3. Restart Strawberry after permission changes.
Windows:
1. Enable microphone access.
2. System audio capture works without extra permissions.
## Settings
At `strawberry://settings/transcription`, configure:
* Microphone
* Spoken languages
* Preferred terms
* Scheduled meeting notifications
* Auto-detected meeting notifications
* Advanced noise thresholds
* Level tests
## Where transcripts appear
Open `strawberry://knowledge/transcriptions` to browse saved transcriptions.
For a specific companion, open companion settings and click **Transcripts** in the General tab. This opens **Files -> Your workspace -> transcripts**.
## Troubleshooting
See [Transcription troubleshooting](/troubleshooting/transcription) for audio, permissions, accuracy, and meeting toast issues.
# Use case templates
Source: https://docs.strawberrybrowser.com/knowledge/use-case-templates
Use Strawberry's curated use case templates for sales, recruiting, operations, marketing, scraping, research, and analysis.
Use case templates are curated starter prompts. They help you discover useful Strawberry workflows without writing a prompt from scratch.
Open templates at `strawberry://knowledge` or from the new tab page at `strawberry://newtab`.
## Categories
The current shared category list includes:
* Sales
* Recruiting
* Operations
* Marketing
* Scraping
* Research and Analysis
Some templates are general and may not belong to only one category.
## Examples
Templates in the codebase include workflows such as:
* Build a personalized outreach sequence
* Enrich a lead list with decision-maker contacts
* Find new leads
* Research a prospect before a meeting
* Research event attendees and send outreach
* Keep a CRM updated from emails
* Build a market authority report
* Analyze a competitor's website and positioning
* Source candidates on LinkedIn
* Set up a daily morning briefing
* Triage an inbox and draft replies
* Audit what Strawberry can do for your company
* Migrate n8n automations to Strawberry routines
* Forward invoices to a bookkeeper
## How to use a template
1. Open `strawberry://knowledge` or `strawberry://newtab`.
2. Pick a category filter if useful.
3. Click a template.
4. Review the pre-filled prompt.
5. Add context, constraints, or examples.
6. Send it to the selected companion.
## Best practices
* Treat templates as starting points, not fixed scripts.
* Add the exact source, account, file, or system you want Strawberry to use.
* Tell the companion what output you want.
* Ask it to confirm before sending messages, mutating systems, or spending credits beyond a sample.
# llms.txt and AI readers
Source: https://docs.strawberrybrowser.com/reference/llms-and-ai-readers
Use Strawberry docs with AI readers through llms.txt, stable page descriptions, and maintained navigation.
`llms.txt` is a compact index for AI readers. It lists documentation pages with human-readable descriptions so assistants can discover the right source before answering.
The Strawberry docs app includes `llms.txt` at the project root. When deployed, it should be available at:
```text theme={null}
https://docs.strawberrybrowser.com/llms.txt
```
## Why it matters
Users often ask assistants questions like:
* "Where do I manage Strawberry team billing?"
* "How do credits work?"
* "Can Strawberry import from Chrome?"
* "How do routines decide when to notify me?"
`llms.txt` helps AI readers find the relevant docs page instead of guessing from memory.
## Maintenance rules
When adding or moving docs pages:
1. Update `docs.json`.
2. Update `llms.txt`.
3. Run `pnpm --filter docs validate:local`.
4. If the behavior also appears inside Strawberry, update the in-product docs in `apps/api-v2/src/routes/documentation`.
## Page descriptions
Keep frontmatter descriptions specific. They should answer what the page covers, not repeat generic marketing copy.
Good:
```text theme={null}
description: Configure per-app tool permissions so companions ask, always allow,
or cannot use specific connected app actions.
```
Weak:
```text theme={null}
description: Learn more about permissions.
```
# Strawberry URLs
Source: https://docs.strawberrybrowser.com/reference/strawberry-urls
Reference for common strawberry:// routes for settings, account, billing, teams, knowledge, routines, downloads, and browser pages.
Paste these routes into the Strawberry address bar.
## Core routes
| Route | Purpose |
| ------------------------ | --------------------------------------------------------- |
| `strawberry://newtab` | New tab page with chat input and use case recommendations |
| `strawberry://settings` | Settings, redirects to account by default |
| `strawberry://downloads` | Downloads history |
| `strawberry://knowledge` | Knowledge page |
| `strawberry://routines` | Routines list |
## Settings
| Route | Purpose |
| --------------------------------------- | ----------------------------------------------------------------- |
| `strawberry://settings/account` | Account overview, plan summary, invite codes, and account actions |
| `strawberry://settings/pricing` | Billing, plans, receipts, and subscription controls |
| `strawberry://settings/team` | Team management, roles, seats, billing, and overage |
| `strawberry://settings/integrations` | Connected apps and tool permissions |
| `strawberry://settings/ai-permissions` | Global AI permission mode and permission summary |
| `strawberry://settings/transcription` | Meeting recording and transcription setup |
| `strawberry://settings/extensions` | Browser extensions |
| `strawberry://settings/profiles` | Profiles and import |
| `strawberry://settings/theme` | Theme, profile color, and tab layout |
| `strawberry://settings/search-engine` | Search engine selection |
| `strawberry://settings/default-browser` | Default browser setting |
| `strawberry://settings/bookmarks` | Bookmarks |
| `strawberry://settings/password` | Saved passwords |
| `strawberry://settings/downloads` | Download location and save behavior |
| `strawberry://settings/privacy` | Privacy and browsing data controls |
| `strawberry://settings/storage` | Storage usage and cleanup |
## Knowledge
| Route | Purpose |
| --------------------------------------- | ------------------ |
| `strawberry://knowledge` | Use case templates |
| `strawberry://knowledge/memory` | Memory files |
| `strawberry://knowledge/reports` | Reports |
| `strawberry://knowledge/skills` | Global skills |
| `strawberry://knowledge/transcriptions` | Saved transcripts |
## Routines
| Route | Purpose |
| -------------------------------- | -------------------------------------------- |
| `strawberry://routines` | Routine list |
| `strawberry://routines/history` | Aggregate run history |
| `strawberry://routines/new` | Open routines with the create-routine dialog |
| `strawberry://routines/:id` | Routine detail |
| `strawberry://routines/:id/edit` | Edit routine |
# Credit troubleshooting
Source: https://docs.strawberrybrowser.com/troubleshooting/credits
Understand unexpected credit drops, free-plan sizing, rate-limit windows, top-ups, team overage, and how to reduce usage.
If credits changed unexpectedly, first check whether a companion response, agent run, routine, transcription follow-up, or connected app task recently ran.
## Credits dropped without an obvious agent
Normal chat replies can use credits. A visible agent block is not required for AI usage.
Long prompts, attached files, large tab context, and advanced models can increase cost.
## Free plan did less than requested
On free plans, Strawberry may do a smaller representative version of a large task first. Ask it to continue or scale up after reviewing the sample.
## Rate-limit window is active
A rate-limit window is a short-term usage guardrail. It can appear even if monthly credits remain.
Open the chat content panel to see the active window and refill time.
## Top-ups not used yet
Top-up credits are used after included monthly credits run out. They do not expire at month end.
## The balance belongs to the wrong account
If you have personal and team credits, check which credit account is active. Open the profile menu -> **Credit account**, compare the listed balances, and select the account you want new AI work to use.
On the web, open **Account** -> **Billing & usage** -> **Credit account**. Switching accounts does not move existing credits.
## Team overage blocked
New teams default to a \$0 overage limit. If team overage is blocked, an owner or admin can adjust the limit at `strawberry://settings/team`.
## Reduce usage
* Ask for a plan before execution.
* Ask for a sample before a large batch.
* Limit rows, pages, sources, or candidates.
* Use files and connected apps instead of pasting huge text.
* Stop or steer off-track chats.
* Save stable context in memory.
* Save repeated process in skills.
# Storage and cleanup troubleshooting
Source: https://docs.strawberrybrowser.com/troubleshooting/storage-and-cleanup
Free up storage, manage large chats, understand public links, and choose the right cache or site data cleanup action.
Use `strawberry://settings/storage` for app storage and `strawberry://settings/privacy` for browser data cleanup.
## Check storage usage
1. Open `strawberry://settings/storage`.
2. View total storage used.
3. Open **More** for category breakdown.
Empty chats are not saved to disk until you send your first message.
## Free up space
Use storage settings to clean large local categories such as chat images or large chats when available.
For site-specific data, use privacy settings or site settings.
## Cache versus cookies and site data
* **Clear Cache** keeps cookies, local storage, IndexedDB, and saved site data.
* **Clear Cookies and Site Data** signs you out of websites and can remove preferences.
* Site **Clear cache** clears only that site's cache storage and Strawberry website metadata cache.
* Site **Clear site data** removes that site's cookies, local storage, IndexedDB, WebSQL, service workers, and cache storage.
## Public links
Public file links are snapshots. If you change the source file or folder, publish again to update the public view.
To stop access, revoke the link from the share dialog.
## File preview issues
Spreadsheet files such as `.xlsx`, `.xls`, `.csv`, and `.tsv` render as tables in chat artifact previews. Unsupported binary files show an **Open externally** option.
HEIC and HEIF image attachments are converted to JPEG during chat image preparation before AI upload.
# Support logs and issue reports
Source: https://docs.strawberrybrowser.com/troubleshooting/support-logs
Send Strawberry issue reports with logs, describe reproduction steps, and know what information helps support.
Use **Strawberry** -> **Report Issue** from the application menu to send an issue report.
The message field is optional, but a useful report helps the team diagnose faster.
## What gets shared
Submitting an issue report shares your local `app.log` with Strawberry support.
Logs help diagnose crashes, failed integrations, update problems, migration issues, transcription problems, and browser errors.
## What to include
Add:
* What you were trying to do
* What happened instead
* The route or page you were on
* Whether the issue repeats
* The relevant connected app
* The time the issue happened
* Any visible error message
## Billing or account issues
For billing issues, include:
* Account email
* Plan or team involved
* Whether it happened in personal billing or team billing
* Stripe portal behavior if relevant
* What action you took, such as upgrade, downgrade, cancel, top-up, add card, invite, or seat change
## Privacy note
Do not paste secrets, passwords, private customer data, or sensitive tokens into the issue message.
## Before reporting
For local app issues, try:
1. Restart Strawberry.
2. Reproduce the issue once.
3. Report immediately after reproducing so logs contain the relevant event.
# Transcription troubleshooting
Source: https://docs.strawberrybrowser.com/troubleshooting/transcription
Fix microphone, system audio, permissions, accuracy, server, meeting notification, and transcript location issues.
Use this page when transcription, dictation, or meeting recording does not behave as expected.
Open transcription settings at `strawberry://settings/transcription`.
## No audio detected
1. Check that the correct microphone is selected.
2. Click **Refresh** to re-scan devices.
3. Confirm microphone permission is granted.
4. Try the built-in microphone.
5. Restart Strawberry.
## macOS permissions not taking effect
After granting microphone or screen and system audio access, restart Strawberry from `strawberry://settings/transcription`.
macOS permission changes often do not apply to already-running apps.
## Remote meeting audio missing
On macOS, system audio capture requires screen and system audio permission. Enable it, then restart Strawberry.
On Windows, system audio capture works without additional permissions.
## Poor accuracy
Try:
* Add spoken languages instead of relying on auto-detect.
* Add preferred terms for names, brands, acronyms, and jargon.
* Switch from Bluetooth headset microphones to the built-in microphone.
* Use **Test levels** to verify input.
* Adjust noise thresholds in Advanced settings.
## Cannot reach transcription servers
Transcription requires internet access. Check network connectivity, VPN rules, and firewall restrictions.
## Meeting toast not appearing
Check:
* Scheduled meeting notifications are enabled.
* Auto-detected meeting notifications are enabled.
* Google Calendar is connected for scheduled reminders.
* The meeting URL belongs to Google Meet, Zoom, or Microsoft Teams.
## Where is my transcript?
Open `strawberry://knowledge/transcriptions`.
For a companion-specific view, open companion settings and click **Transcripts** in the General tab.