Tines 3B
Tines v1.0.3
Build, run, monitor, govern
From the developer
Declared capabilities
- Explore spaces and workflows
- Build and improve workflows
- Run workflows and inspect executions
Cost & access
This plugin does not sell products or process payments.
Declared limitations
- Access an unauthorized space
- Publish without confirmation
- Reveal protected credentials
Onboarding example
Help me build and run a Tines 3B workflow for this process.
Sources & dates
Developer declarations; not independently tested. Listing last checked Nov 17, 2026. Package observed Nov 17, 2026.
Description
From the marketplace listing
Use Tines 3B to build, run, monitor, and govern AI agents, apps, and automations from ChatGPT and Codex. Work across the spaces and workflows available to your connected account, run and improve workflows, and inspect operational and AI usage data. Tines 3B keeps credentials protected, executes steps in isolation, and applies your organization's existing access controls and audit trail.
Language: English · Automatically detected from descriptions.
Changes
No changes recorded yet. Follow this plugin to keep track of future changes.
First seen Nov 17, 2026. Last seen Nov 17, 2026.
Similar plugins
Find competitors to follow as you develop your plugin.
-
Openlayer helps teams inspect AI projects, data sources, traces, tests, evaluation results, and governance controls, and manage private w...
Shared terms: govern, monitor, control, inspect
-
Build, test, and deploy automated workflows. NoClick makes automation accessible — connect your favorite tools, add logic and AI steps, a...
Shared terms: run, automation, step
-
Camber lets users manage accounts and workspaces, discover or create agents, and launch and monitor agent runs directly within ChatGPT.
Shared terms: run, monitor, agent
-
Build, run and analyze approval workflows. Approveit connects ChatGPT to your organization's approval workflows, within the permissions o...
Shared terms: run, audit, organization, trail
-
JoinLayer helps users inspect data connections, create and validate pipelines, preview transformed and enriched records, run or stop appr...
Shared terms: run, monitor, usage, inspect
Keywords
Files & skills
File archives
Skill instructions
building-agents10.6 KB
--- name: building-agents description: Build the AI parts of a 3B workflow — any step that calls a language model. Use whenever a task calls a model (Anthropic, OpenAI, Gemini, …) or is model-shaped — summarize, extract, classify, generate, rewrite, answer, converse, or a tool-using agent — even if “AI” or “agent” is never said. Covers choosing the shape, the agent step, the mandatory self-loop for async agents, tools, model choice, conversations, chat UIs, and single-request calls. Pair with the claude-api skill for Anthropic-native features (Batches, the Files API). license: Apache-2.0 compatibility: Tines 3B --- # Building AI into a 3B workflow An “AI step” is any step that calls a model. Pick the simplest shape that does the work, wire it the 3B way, and don’t hand-roll what the agent template already gives you. ## Choose the shape Simpler shapes mean less latency, cost, and breakage — but under-powering is just as real a failure: a task that has to gather context or act, crammed into one call, gives a worse answer, not a simpler one. The deciding question isn’t how much fits in the prompt; it’s whether you can name every input up front. 1. **Single request** — one call in, one result out, no tools. Use it when you can assemble the complete input ahead of time and the job is to transform it: classify, extract, summarize, generate, rewrite, answer a self-contained question. If a regex or lookup would do, don’t call a model at all. 2. **Agent** — one model with tools, looping until it’s done. Use it the moment a good answer depends on context the model has to _choose to pull_, or on _doing_ something and reacting to the result: reading the files a diff touches, following a lead, searching, calling an API, then deciding what’s next. The tell: you can’t list the inputs up front, because they depend on what the model finds. Pre-fetching that context in code and pasting it into one call is the trap — it looks like it “puts everything in the prompt”, but it freezes what the model can consider to whatever you guessed and caps the quality of the answer. When the user asks for an “agent”, this is the shape they mean — and one pass is not an agent. ## The agent step Copy the `agent` template — never hand-roll the model loop, in-process or as a chain of AI steps. The template is the canonical implementation of what a correct agent guarantees: - **Loops until the model signals done** — a turn ending with no tool call. - **Stops at its bounds** — step caps (per run, and across all of a conversation’s runs), token budget, and wall clock end the run with the transcript persisted and a terminal event, never a runaway loop or a mid-write kill. - **Streams to a watching caller** — text, reasoning, tool calls and results, and usage flow as they happen, never one blob at the end. A headless run instead writes a single structured result — the stream is noise to downstream steps, and the full trail is in the transcript. - **Persists the transcript durably every run** — messages, tool calls, results, and the whole usage object (cache and reasoning tokens are priced separately): the audit trail, debugging surface, and cost record. - **Isolates conversations by the authenticated caller** — a client-supplied conversation id is never an access check. You normally touch five things: `system.md` (who the agent is, its tools, and when to stop or ask before an irreversible action), `tools/` (one tool per file — see Tools), `model.json` (provider, model, effort, thinking, run limits), `config.toml` (connect the provider; add a `route` plus `output = true` only when a caller invokes the agent directly — without them it’s a headless node: the upstream step’s output in, one structured result out), and `buildInput` in `agent.ts` — the function **you** own that shapes this workflow’s trigger payload (the upstream step’s output, or the route’s request body) into the agent’s message, tool context, and, for chat, the conversation to continue. The templat
Preview of the first 4,000 characters. Read full instructions →
building-workflows9.21 KB
---
name: building-workflows
description: Build and modify Tines 3B workflows from a workflow or space Git checkout, the 3B MCP server, the 3B CLI, or the in-product editor. Use whenever an agent works with workflow.toml, step directories, config.toml, Dockerfiles, workflow routes, links, triggers, connectors, step tests, or needs to create, inspect, run, debug, commit, or publish a 3B workflow.
license: Apache-2.0
compatibility: Tines 3B
---
# Build 3B workflows
- Read [references/interfaces.md](references/interfaces.md) when choosing or using an editing interface.
- Read [references/testing.md](references/testing.md) before running a step or creating, updating, or running step tests.
- Read [references/routes.md](references/routes.md) before adding or changing a step with `route`: authentication modes, `api.json`, identity and consent headers, cookies, long-running requests, and route URLs.
- Read [references/connectors.md](references/connectors.md) before searching for, attaching, or calling a connector, or when a visitor-mode connector answers `403`.
- Read [references/tunnels.md](references/tunnels.md) when a step must reach a private network or on-premises service.
- Read [references/dockerfile.md](references/dockerfile.md) before changing a step’s Dockerfile, dependencies, build layers, or cache mounts.
- Read [references/volumes.md](references/volumes.md) before a step writes to a volume: concurrency, draft storage set-up, and publish semantics.
## Layout
```text
README.md
<Step name>/
README.md
config.toml
Dockerfile
...
```
Within a workflow checkout, each top-level directory is a uniquely named step. Keep a `README.md` at the root and in every step describing purpose, trigger, and behavior; the UI already displays the workflow or step name, so do not repeat it as the opening heading.
A cloned 3B space adds one directory per workflow:
```text
<Workflow name>/
workflow.toml
README.md
<Step name>/
...
```
`workflow.toml` identifies an existing workflow. Preserve its `id`, and never copy it into another workflow directory. In a 3B-hosted space clone, pushing a new top-level directory without `workflow.toml` creates that workflow as a draft from a non-`main` branch or in Live from `main`; 3B writes the identity file back.
## Step templates
Templates map to `shell` → `script.sh`, `python` → `script.py`, `typescript` → `script.ts` on Bun, `react` → `App.tsx` with React and Tailwind, and `agent` → `agent.ts`. React templates set `output = true`.
Copy the closest template available through the current interface. Default to TypeScript for data processing when the user has not requested another language. In a Git checkout without interface-provided templates, copy the matching directory from [assets/templates](assets/templates) into the workflow and rename it for the step. A step may contain and import additional source files; the template entry point is the command the runtime invokes. A step builds from its own folder only, so it can’t import files from the workflow root or another step: copy a shared helper into each step that uses it. Add Python dependencies to `requirements.txt` and TypeScript or React dependencies to `package.json`; preserve the template’s install and cache layers instead of adding ad hoc installs to the Dockerfile.
For React, default to one step for one application. Do not place the UI downstream of a data step: render it immediately and fetch data from route steps. For multi-page applications, use `BrowserRouter` with `basename={window.__ROUTE_PATH__}` and relative route paths; the template computes the branch-aware base path. Use Tailwind’s built-in palette and spacing scale, and avoid adding browser dependencies without a concrete need. Render a descriptive `<title>` for every page.
## `config.toml`
All fields are optional at runtime, and a missing `color` defaults to `sky`. Set a color in authored steps, and omit unused fields rather than writing empty values.
```tomPreview of the first 4,000 characters. Read full instructions →
Referenced files: 43 — file references are metadata, not package contents.
claude-api4.77 KB
---
name: claude-api
description: Build, debug, and optimize code that calls the Claude (Anthropic) API. Use when writing a step or service that calls Claude — covers picking a surface, the Messages API, choosing a model, prompt caching, tool use, streaming, thinking, and batch.
license: Apache-2.0
compatibility: Tines 3B
---
# Calling the Claude API
Use the official Anthropic SDK for the language you are in (`anthropic` for Python, `@anthropic-ai/sdk` for TypeScript), or raw HTTP only when there is no SDK or the request is explicitly a cURL/REST one. Never mix the two, and never swap in an OpenAI-compatible shim. Read the API key from a 3B credential or connector rather than hardcoding it.
## Connector URLs and authentication
For Anthropic and Microsoft Foundry Claude connectors, pass a placeholder API key; the proxy injects the real key. Keep the saved connector URL including `/v1` for connection tests and credential injection. The official SDK appends `/v1`, so remove only that suffix when constructing its client, preserving gateway prefixes such as `/anthropic`:
```typescript
const client = new Anthropic({
baseURL: process.env.ANTHROPIC_BASE_URL!.trim().replace(/\/v1\/?$/, ""),
apiKey: "placeholder",
});
```
```python
client = anthropic.Anthropic(
base_url=os.environ["ANTHROPIC_BASE_URL"].strip().rstrip("/").removesuffix("/v1"),
api_key="placeholder",
)
```
Use `ANTHROPIC_BASE_URL` unchanged with `@ai-sdk/anthropic`; for raw HTTP, trim its trailing slash and append `/messages`.
## Pick the simplest surface that works
- **Single call** — classification, summarization, extraction, Q&A. One request, one response.
- **Workflow (call + tool use)** — multi-step logic you orchestrate in code. You control the loop; Claude calls the tools you define.
- **Agent** — Claude decides its own trajectory using your tools. Only reach for this when the task is genuinely open-ended, the value justifies the cost, and errors are recoverable.
Everything goes through `POST /v1/messages`. Tool use and structured outputs are features of that one endpoint, not separate APIs.
## Choosing a model
Use the current Claude models — Fable for the hardest knowledge work and coding, Opus for demanding general work, Sonnet for a balance of speed and intelligence, and Haiku for cheap, fast work. Use the exact model ID string (e.g. `claude-fable-5`, `claude-opus-5-5`, `claude-sonnet-5`, `claude-haiku-4-5`) and **do not append a date suffix**. If you need the live context window or capabilities of a model, query the Models API (`client.models.list()` / `client.models.retrieve(id)`) rather than relying on memory. Don’t silently downgrade a model to save cost — that’s the caller’s decision.
## Prompt caching (do this by default)
Caching is a prefix match: any byte change anywhere in the prefix invalidates everything after it. Render order is `tools` → `system` → `messages`. Put stable content first (frozen system prompt, deterministic tool list) and volatile content (timestamps, per-request IDs, the varying question) last, after your final `cache_control` breakpoint. The minimum cacheable prefix varies by model — 512 tokens for Opus 5.5, Opus 5, and Fable 5, 1024 for Sonnet 5, and 4096 for Haiku 4.5 — and differs again on Bedrock, so check the prompt caching docs for the model you picked. Verify it works by checking `usage.cache_read_input_tokens` across repeated requests — if it stays zero, a silent invalidator (a `datetime.now()` in the system prompt, unsorted JSON, a varying tool list) is breaking the prefix.
## Tool use
Define each tool with a clear name, a JSON-schema input, and a concise description. Either use the SDK’s tool runner to handle the call → execute → loop cycle automatically, or write the loop yourself when you need approval gates or custom logging. Append the model’s full `response.content` back onto the message list each turn — not just the text — or you’ll lose tool-call and thinking state.
## Streaming and thinkPreview of the first 4,000 characters. Read full instructions →
cross-tool-research992 Bytes
--- name: cross-tool-research description: Find, correlate, summarize, and investigate information across the user’s connectors. Use for cross-tool searches, conversation or ticket summaries, and investigations that need alerts, logs, messages, documents, or code context. license: Apache-2.0 compatibility: Tines 3B --- # Cross-tool research Clarify the target when the request does not identify a person, project, incident, channel, ticket, or time range. Search the most likely authoritative sources first, then follow identifiers and links across connectors. Keep evidence separate from inference. Report: - The direct answer or current state - A short timeline when sequence matters - The source of each important fact - Conflicts, missing evidence, and unresolved questions - The next useful query or action For investigations, start with the observed symptom, establish scope and timing, correlate recent changes, and avoid claiming a root cause until the evidence supports it.
daily-briefing859 Bytes
--- name: daily-briefing description: Build a concise briefing from calendars, tasks, tickets, pull requests, messages, and documents. Use when the user asks what needs attention, what is assigned to them, or how to prepare for an upcoming meeting. license: Apache-2.0 compatibility: Tines 3B --- # Daily briefing Gather current information from the user’s relevant connectors before summarizing it. Prioritize: - Time-sensitive meetings, deadlines, incidents, and requests - Work explicitly assigned to the user - Threads or reviews waiting on the user - Recent changes that alter today’s priorities Group related items, identify the source of each fact, and distinguish confirmed commitments from suggestions. For meeting preparation, include the purpose, participants, recent related work, unresolved questions, and a short preparation checklist.
dashboard-design7.25 KB
---
name: dashboard-design
description: Build polished, interactive analytics dashboards for any data source. Use this whenever the request involves a dashboard, data visualization, internal metrics, spend/usage/cost reporting, or any UI that shows data sliced across time, users, categories, or other dimensions — even if the word "dashboard" is never used. Covers cross-filtering, shareable URL state, filter models, legends, transitions, honest handling of incomplete data, and visualization craft. Not needed for a single static chart.
license: Apache-2.0
compatibility: Tines 3B
---
# Building analytics dashboards
Build it as a structured project — components, hooks, and helpers in separate files, not one giant file. Hand-rolled SVG is fine, often better than a chart library for bespoke interactions.
A dashboard answers questions; it isn't a page of charts. Its dimensions (time plus the data's categorical axes) are the product: make every one filterable, cross-linked, and honest about what it can't show.
For the visual identity — type, palette, spacing, and polish — use the **frontend-design** skill, and ask the user for brand guidelines or a reference if the direction isn't clear. This skill covers only what's specific to data and dashboards: pipeline, interaction, and visualization.
## Data pipeline
If the dashboard stores source data or derived views in named volumes, use `workflow-volume-design` for file ownership, bounded updates, retention, and capacity.
- Refresh on a schedule, and let users trigger a refresh on demand. Coalesce concurrent refreshes so they do not stampede the source. Put the schedule on one entry point that fans out to the fetchers, so cadence lives in one place.
- Fetch incrementally: pull only what's new since the last stored point, but keep a full-backfill path for a cold or empty store.
- Retry transient source failures with backoff, and never overwrite good data with an empty or failed result — a bad fetch leaves the last good data in place.
- Store raw source data under a stable schema so display changes don’t force a re-fetch. Keep the inputs to a transform, such as a lookup table, so derived views can be rebuilt when mappings change. Retain only the history the product needs.
- Aggregate on the fly only while the query remains bounded. When the raw volume is too large to load and roll up per request, query pre-summarized data at the source or precompute bounded rollups during refresh.
- Let users download the data (e.g. CSV): the processed rows behind the current view (respecting active filters, for finance/reporting) and/or the raw records (for their own analysis).
## Everything is a filter, selection is shared
- Clicking any mark (bar, legend entry, table row, node) scopes every other view to it, and dims (not removes) the rest of the clicked chart.
- Selection toggles: click again or `Esc` to clear. Never strand the user in a dead-end (a flow diagram filtered to one node shows nothing — exit the filter instead).
- Don't filter to a value that can't resolve — an "Others"/"+N more" bucket isn't real; expand it on hover.
- Drill-down: clicking one side of a relationship diagram can expand it and filter the other.
## Shareable URL state
Encode all view state in the URL (tab, date range, filters, grouping, granularity, scale, drill-down) so any view shares by copying the address. Keep param names matching the labels users see.
## Filters
- Multi-select by default, with an include/exclude mode ("only these" vs "all except these"). Show a count when collapsed.
- When one dimension groups another, put the parent first and scope the child's options to the parent's selection.
- Default to a recent window grouped by the dimension people care about most — not "all time", not the first column.
- Don't offer a granularity coarser than the window; disable options that can't apply.
## Legends
- Default the legend to the whole visible period, so its prominence matches the chart — not the last daPreview of the first 4,000 characters. Read full instructions →
docx6.58 KB
---
name: docx
description: Create, edit, and read Word documents (.docx) with python-docx. Use whenever the user wants a Word file as output — a report, memo, letter, contract, proposal, or template fill — or uploads a .docx to summarize, review, comment on, redline, or rewrite, even if they only say “document” or “Word”.
license: Apache-2.0
compatibility: Tines 3B
---
# Word documents
Work with `.docx` files in Python through `execute`, adding `python-docx==1.2.0` to a `requirements.txt` in `files`. In a workflow step, add it to the step’s `requirements.txt` instead.
User uploads arrive under `/3b/uploads/<id>/<file>`, which every execution can read. Write output to a persistent volume, such as `volumes: ["documents"]` and `/storage/documents/report.docx`, then call `showStorageFile` so the user can preview and download it. Never overwrite the user’s upload: save edits as a new file, and call `showStorageFile` again after each change.
## Reading
Walk the body in order so paragraphs and tables stay interleaved as the author wrote them:
```python
from docx import Document
from docx.table import Table
from docx.text.paragraph import Paragraph
doc = Document("/3b/uploads/abc/contract.docx")
for block in doc.iter_inner_content():
if isinstance(block, Paragraph) and block.text.strip():
print(f"[{block.style.name}] {block.text}")
elif isinstance(block, Table):
for row in block.rows:
print(" | ".join(cell.text for cell in row.cells))
```
python-docx skips text inside tracked insertions (`w:ins`), text boxes, and footnotes. If the document has redlines or the output looks incomplete, read `word/document.xml` from the zip as well.
## Creating
Structure first, styling second. Use the built-in styles rather than hand-formatting each paragraph: Word builds its navigation pane and table of contents from real headings, and a restyle then changes the whole document at once.
```python
from docx import Document
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.oxml import OxmlElement
from docx.oxml.ns import qn
from docx.shared import Inches, Pt
doc = Document()
section = doc.sections[0]
section.page_width, section.page_height = Inches(8.5), Inches(11)
for side in ("left_margin", "right_margin", "top_margin", "bottom_margin"):
setattr(section, side, Inches(1))
normal = doc.styles["Normal"]
normal.font.name = "Calibri"
normal.font.size = Pt(11)
doc.add_heading("Quarterly access review", level=0)
doc.add_paragraph("Summary of findings for Q3.")
doc.add_heading("Findings", level=1)
doc.add_paragraph("Three dormant admin accounts", style="List Bullet")
doc.add_paragraph("Disable dormant accounts", style="List Number")
table = doc.add_table(rows=1, cols=3, style="Light Grid Accent 1")
for cell, label in zip(table.rows[0].cells, ("System", "Owner", "Status")):
cell.text = label
for values in (("Okta", "IT", "Done"), ("AWS", "Platform", "Open")):
for cell, value in zip(table.add_row().cells, values):
cell.text = value
footer = section.footer.paragraphs[0]
footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
for kind, text in (("begin", None), (None, "PAGE"), ("end", None)):
run = footer.add_run()
if kind:
field = OxmlElement("w:fldChar")
field.set(qn("w:fldCharType"), kind)
else:
field = OxmlElement("w:instrText")
field.text = text
run._r.append(field)
doc.save("/storage/documents/access-review.docx")
```
- `Document()` defaults to US Letter. Use A4 (`Mm(210)` × `Mm(297)`) when the user or their organization is outside North America.
- Add images with `doc.add_picture(path, width=Inches(6))`. Render charts to PNG with matplotlib first, at 200 DPI or more.
- Start a new page with `doc.add_page_break()`, not a run of empty paragraphs.
- Python-docx has no table-of-contents builder. Insert a `TOC \o "1-3" \h` field the same way as the page number above, and tell the user to update fields in Word to fill it.
- Keep tables to five or siPreview of the first 4,000 characters. Read full instructions →
Referenced files: 1 — file references are metadata, not package contents.
frontend-design4.81 KB
--- name: frontend-design description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics. license: Apache-2.0 compatibility: Tines 3B --- This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices. The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints. ## Design Thinking Before coding, understand the context and commit to a BOLD aesthetic direction: - **Purpose**: What problem does this interface solve? Who uses it? - **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction. - **Constraints**: Technical requirements (framework, performance, accessibility). - **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember? **CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity. Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is: - Production-grade and functional - Visually striking and memorable - Cohesive with a clear aesthetic point-of-view - Meticulously refined in every detail ## Request Lifecycle Treat network activity as part of the interface’s lifecycle. When a page refreshes remote state, own one loop at the page or collection boundary, batch related item checks when possible, and start the next refresh only after the current request settles. Stop refreshing terminal data and cancel outstanding work when the page unmounts. Never create one asynchronous polling timer per rendered item or allow timer ticks to overlap in-flight requests. ## Frontend Aesthetics Guidelines Focus on: - **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font. - **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. - **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise. - **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density. - **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays. NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients
Preview of the first 4,000 characters. Read full instructions →
internal-comms2.77 KB
--- name: internal-comms description: Write internal communications — status reports, leadership updates, incident reports, project updates, FAQs, and newsletters — in clear, consistent formats. Use whenever drafting an internal update, announcement, or report for a team or company. license: Apache-2.0 compatibility: Tines 3B --- # Internal communications Good internal comms respect the reader’s time. Lead with the point, keep it skimmable, and say only what the audience needs to act or stay informed. ## Principles - **Lead with the takeaway (BLUF).** The first line should carry the most important information — the decision, the status, the ask. Don’t bury it under context. - **Know the audience.** A leadership update is terser and more outcome-focused than a team update. Match the altitude. - **Make it skimmable.** Short paragraphs, headers, and bullets. Bold the few words that matter. - **Be specific.** Dates, owners, numbers, and links beat adjectives. “Shipped to 100% on Tuesday” beats “made great progress.” - **State the ask.** If you need a decision, a review, or nothing at all, say which. ## Formats **3P update (Progress / Plans / Problems)** — a recurring team update: - _Progress_ — what got done since the last update. - _Plans_ — what’s next, with rough timing. - _Problems_ — blockers, risks, and where you need help. **Status report** — headline status (on track / at risk / off track), a one-line summary, then key updates, risks, and next steps. **Leadership update** — outcomes and decisions, not activity. Open with the headline, then progress against goals, the top risks, and any decisions you need from them. Keep it short. **Incident report** — a summary line (what happened, impact, current state), then _impact_ (who/what was affected, for how long), a _timeline_ of key events, _root cause_, _remediation_ (what fixed it), and _follow-ups_ (owners + dates to prevent recurrence). Write blamelessly — focus on systems, not people. **Project update** — where the project stands against its plan: milestones hit, what’s next, risks, and changes to scope or timeline. **FAQ** — group by theme; lead each answer with the direct response, then the detail. Anticipate the real questions, including the uncomfortable ones. **Newsletter** — a short, scannable digest: a brief intro, themed sections with headers, and clear links out for depth. Celebrate wins concretely and credit the people involved. ## Tone Clear, warm, and direct. Plain language over jargon. Confident without overclaiming — if something is uncertain or went wrong, say so plainly and say what happens next. --- _Adapted by 3B from Anthropic’s “internal-comms” skill (github.com/anthropics/skills), © Anthropic PBC, licensed under Apache-2.0. Modified for 3B._
mcp-builder12.6 KB
--- name: mcp-builder description: Build high-quality MCP (Model Context Protocol) servers that let an AI interact with external services through well-designed tools. Use whenever you are building an MCP server to integrate an external API or service, in either Python (FastMCP) or TypeScript (MCP SDK). When the server is deployed as a 3B workflow, put it behind the built-in `space` or `tenant` route auth and let the platform authenticate clients instead of implementing the MCP OAuth handshake in the server. license: Apache-2.0 compatibility: Tines 3B --- # Building an MCP server An MCP server exposes an external service to an AI as a set of tools. Its quality is measured by one thing: how reliably an AI can use those tools to accomplish real tasks. Build for the AI that will call it, not for human readers of the API. ## Phase 1 — Research and plan - **Read the service’s API docs first.** Identify the key endpoints, the auth model, rate limits, and the core data shapes. Use web search and fetch the live docs rather than guessing. - **Read the MCP spec and SDK docs.** Start from the sitemap at `https://modelcontextprotocol.io/sitemap.xml`, then fetch specific pages with a `.md` suffix. For the SDKs, fetch the TypeScript SDK README (`github.com/modelcontextprotocol/typescript-sdk`) or Python SDK README (`github.com/modelcontextprotocol/python-sdk`). - **Decide coverage vs. workflow tools.** Comprehensive endpoint coverage gives the AI flexibility to compose operations; a few higher-level workflow tools are more convenient for common tasks. When unsure, prioritize comprehensive coverage and add workflow tools for the hot paths. ## Phase 2 — Implement **Recommended stack:** TypeScript with the MCP SDK. Use streamable HTTP with stateless JSON for remote servers (simple to scale), and stdio for local servers. Build shared infrastructure once: an authenticated API client, error-handling helpers, response formatting, and pagination. For each tool: - **Name it clearly and consistently.** Use an action-oriented, prefixed scheme — `github_create_issue`, `github_list_repos` — so the AI can find the right tool fast. - **Define a strict input schema** with Zod (TypeScript) or Pydantic (Python). Add constraints, clear field descriptions, and examples in the descriptions. - **Define an output schema** where possible and return structured content, not just text — it helps the client parse results. - **Return focused data.** Support filtering and pagination so a single call can’t flood the context window. - **Write actionable errors.** An error should tell the AI what went wrong and what to try next, not just echo a stack trace. - **Set annotations** — `readOnlyHint`, `destructiveHint`, `idempotentHint`, `openWorldHint` — so clients can reason about safety. ## Deploying on 3B — let the platform authenticate clients When the server runs as a 3B workflow (a step with a `route`, `route_type = "api"`), do **not** implement the MCP authorization spec — discovery, dynamic client registration, consent, or token exchange — inside the server. Set `route_auth = "space"` (or `"tenant"`) on the route: the `space` and `tenant` bars accept an OAuth access token as one of their credentials, so 3B handles the entire client-facing OAuth 2.1 handshake at the platform boundary — it serves the protected-resource and authorization-server metadata, registers clients, runs the consent screen, issues and verifies access tokens, and enforces them on every request. ```toml # Routes are unique per space — use a /<server-name>/mcp path, never a bare "/mcp" route = "/github/mcp" route_type = "api" route_auth = "space" output = true ``` Routes are unique within a space, and publishing a second workflow on a path that’s already live is rejected — so give the route a `/<server-name>/mcp` path (`/github/mcp`, `/slack/mcp`) rather than a bare `/mcp`. MCP clients connect to the full URL you hand them, so the path is just a name; there’s no requirement to serve at `/m
Preview of the first 4,000 characters. Read full instructions →
mcp-client4.54 KB
---
name: mcp-client
description: Call tools on a remote MCP (Model Context Protocol) server over streamable HTTP. Use whenever a connector is an MCP server (e.g. the “MCP server” connector type), or the user asks to list or invoke an MCP server’s tools, prompts, or resources.
license: Apache-2.0
compatibility: Tines 3B
---
# Using a remote MCP server
An MCP server is a JSON-RPC 2.0 API behind a single HTTP endpoint. Talk to it with plain `fetch` from `execute` or a step, with the MCP connector attached — the platform injects authentication on matching requests, so never set Authorization headers yourself, and never print or store tokens.
Read the body of every error response, as the helper below does. A `403` with `"error": "connector_not_connected"` means the user hasn’t connected their own account to a visitor-mode connector: show them the body’s `message`, and its `connect_url` as a link if present, then retry once they’ve connected. A `403` whose body is a JSON-RPC error saying a tool “is not allowed by this connector” means the connector only allows the tools its message lists: don’t retry or reconnect, use an allowed tool or tell the user that a connector manager can allow this one. Any other 401 or 403 means the user needs to reconnect the connector; tell them so rather than attempting an auth flow yourself.
## Request basics
Every request is a POST to the server URL with `Content-Type: application/json` and `Accept: application/json, text/event-stream`. The response is either plain JSON or an SSE stream; for SSE, parse each `data:` line as JSON and take the message whose `id` matches your request. This helper handles both:
```ts
let sessionId: string | undefined;
async function mcp(
url: string,
method: string,
params?: Record<string, unknown>,
id?: number
) {
const res = await fetch(url, {
method: "POST",
headers: {
"Content-Type": "application/json",
Accept: "application/json, text/event-stream",
...(sessionId ? { "Mcp-Session-Id": sessionId } : {}),
},
body: JSON.stringify({
jsonrpc: "2.0",
method,
...(params ? { params } : {}),
...(id !== undefined ? { id } : {}),
}),
});
sessionId = res.headers.get("Mcp-Session-Id") ?? sessionId;
const text = await res.text();
if (!res.ok)
throw new Error(`${method}: HTTP ${res.status}: ${text.slice(0, 500)}`);
if (id === undefined) return; // notification, no response expected
const messages = res.headers
.get("Content-Type")
?.includes("text/event-stream")
? text
.split("\n")
.filter((line) => line.startsWith("data:"))
.map((line) => JSON.parse(line.slice(5)))
: [JSON.parse(text)];
const reply = messages.find((m) => m.id === id);
if (!reply) throw new Error(`${method}: no response with id ${id}`);
if (reply.error) throw new Error(`${method}: ${JSON.stringify(reply.error)}`);
return reply.result;
}
```
## Session lifecycle
1. Send `initialize` with `protocolVersion: "2025-06-18"`, `capabilities: {}`, and your `clientInfo`. If the server rejects the protocol version, retry with the version it offers in the error.
2. If the response carries an `Mcp-Session-Id` header, echo it on every subsequent request (the helper above does this).
3. Send a `notifications/initialized` notification (no `id`).
4. When finished, send a DELETE to the endpoint with the session header if the server supports it; ignore a 405.
```ts
await mcp(
SERVER_URL,
"initialize",
{
protocolVersion: "2025-06-18",
capabilities: {},
clientInfo: { name: "3B", version: "1.0" },
},
1
);
await mcp(SERVER_URL, "notifications/initialized");
```
## Tools, prompts, and resources
- `tools/list` returns tool names, descriptions, and JSON Schema inputs. Page with `cursor` if the result has `nextCursor`. Cache the list in a file instead of re-fetching every turn.
- `tools/call` takes `{ name, arguments }`. The result has `content` blocks (usually `{ type: "text"Preview of the first 4,000 characters. Read full instructions →
pdf5.65 KB
---
name: pdf
description: Read, extract from, create, fill, merge, split, and watermark PDF files with pdfplumber, pypdf, and ReportLab. Use whenever the user uploads a PDF to summarize, extract text or tables from, or fill in, or wants a PDF as output — a report, invoice, letter, certificate, or a combined or redacted copy of other PDFs.
license: Apache-2.0
compatibility: Tines 3B
---
# PDFs
Work with PDFs in Python through `execute`, adding the libraries you need to a `requirements.txt` in `files`: `pdfplumber==0.11.10` for extraction, `pypdf==6.20.1` for page and form operations, and `reportlab==5.0.1` for creating new PDFs. In a workflow step, add them to the step’s `requirements.txt` instead.
User uploads arrive under `/3b/uploads/<id>/<file>`, which every execution can read. Write output to a persistent volume, such as `volumes: ["documents"]` and `/storage/documents/report.pdf`, then call `showStorageFile` so the user can preview and download it. Never overwrite the user’s upload.
## Reading
For a short PDF, call `readStorageFile` on it: it returns the PDF for you to view directly, including its layout, charts, and scanned pages. Use code when the document is long, when you need exact values, or when you need tables as data:
```python
import pdfplumber
with pdfplumber.open("/3b/uploads/abc/invoice.pdf") as pdf:
print(len(pdf.pages), pdf.metadata)
for number, page in enumerate(pdf.pages, start=1):
print(f"--- Page {number}")
print(page.extract_text() or "[no text layer]")
for table in page.extract_tables():
for row in table:
print(row)
```
A page with no text layer is a scan. OCR tools aren’t installed in the sandbox, so view those pages with `readStorageFile` instead. Use `page.crop((x0, top, x1, bottom))` to read one region, such as a header block or a single column of a multi-column layout.
## Creating
Use ReportLab’s Platypus layer. It flows paragraphs, tables, and images across pages, so you don’t position each line by hand.
```python
from reportlab.lib import colors
from reportlab.lib.pagesizes import LETTER
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, Table, TableStyle
styles = getSampleStyleSheet()
def footer(canvas, doc):
canvas.setFont("Helvetica", 9)
canvas.drawRightString(LETTER[0] - inch, 0.6 * inch, f"Page {doc.page}")
doc = SimpleDocTemplate("/storage/documents/report.pdf", pagesize=LETTER, title="Incident report",
leftMargin=inch, rightMargin=inch, topMargin=inch, bottomMargin=inch)
table = Table([["System", "Impact", "Status"], ["Okta", "Login delays", "Resolved"]],
colWidths=[2 * inch, 2.75 * inch, 1.75 * inch], repeatRows=1)
table.setStyle(TableStyle([
("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#1F4E79")),
("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
("GRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#BFBFBF")),
("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#F2F2F2")]),
]))
doc.build([
Paragraph("Incident report", styles["Title"]),
Paragraph("Login delays on <b>October 3</b> affected 4% of users for 22 minutes.", styles["BodyText"]),
Spacer(1, 12),
table,
], onFirstPage=footer, onLaterPages=footer)
```
- `Paragraph` takes a small HTML-like markup (`<b>`, `<i>`, `<font>`, `<br/>`), so escape `&`, `<`, and `>` in user text with `xml.sax.saxutils.escape`.
- ReportLab’s built-in fonts (Helvetica, Times, Courier) cover only Latin-1, so other characters render as black boxes. For other text, register a TrueType font. The sandbox includes Liberation fonts under `/usr/share/fonts/truetype/liberation/`, and they cover Latin, Greek, and Cyrillic: `pdfmetrics.registerFont(TTFont("Liberation", ".../LiberationSans-Regular.ttf"))`.
- Use A4 instead of Letter (`from reportlaPreview of the first 4,000 characters. Read full instructions →
pptx6.12 KB
---
name: pptx
description: Create, edit, and read PowerPoint presentations (.pptx) with python-pptx. Use whenever the user wants slides as output — a deck, pitch, briefing, training, or report presentation — or uploads a .pptx to summarize, restyle, update, or extend, even if they only say “slides” or “deck”.
license: Apache-2.0
compatibility: Tines 3B
---
# PowerPoint presentations
Work with `.pptx` files in Python through `execute`, adding `python-pptx==1.0.2` to a `requirements.txt` in `files`. In a workflow step, add it to the step’s `requirements.txt` instead.
User uploads arrive under `/3b/uploads/<id>/<file>`, which every execution can read. Write output to a persistent volume, such as `volumes: ["documents"]` and `/storage/documents/briefing.pptx`, then call `showStorageFile` so the user can preview and download it. Never overwrite the user’s upload: save edits as a new file, and call `showStorageFile` again after each change.
## Reading
```python
from pptx import Presentation
prs = Presentation("/3b/uploads/abc/deck.pptx")
for number, slide in enumerate(prs.slides, start=1):
print(f"--- Slide {number} ({slide.slide_layout.name})")
for shape in slide.shapes:
if shape.has_text_frame and shape.text_frame.text.strip():
print(shape.text_frame.text)
if shape.has_table:
for row in shape.table.rows:
print(" | ".join(cell.text for cell in row.cells))
if slide.has_notes_slide:
print("Notes:", slide.notes_slide.notes_text_frame.text)
```
Group shapes hold their own `shapes`, so recurse into them when text seems missing.
## Plan the deck before writing code
Draft the outline as text first: one line per slide with its title and the point it makes. Confirm it with the user when the request is open-ended. The outline is cheap to change, and the code is not.
- **One idea per slide, with the title stating it.** “Phishing reports doubled after the training” beats “Phishing reports”.
- **Keep text short.** At most five or six bullets, each a single line. Move detail into speaker notes.
- **Show numbers as charts or big figures**, not as sentences full of digits.
- **Be consistent.** Use one title position, one margin, two fonts at most, and a palette of a neutral, a dark text color, and one or two accents.
## Creating
When the user supplies a template or an existing deck in their branding, open it and add slides from its layouts. Its masters carry fonts, colors, and logos you shouldn’t recreate by hand. Otherwise, start from the default and switch it to 16:9, because python-pptx’s default is 4:3.
```python
from pptx import Presentation
from pptx.chart.data import CategoryChartData
from pptx.dml.color import RGBColor
from pptx.enum.chart import XL_CHART_TYPE, XL_LEGEND_POSITION
from pptx.util import Inches, Pt
prs = Presentation()
prs.slide_width, prs.slide_height = Inches(13.333), Inches(7.5)
TITLE_ONLY = prs.slide_layouts[5]
ACCENT = RGBColor(0x1F, 0x4E, 0x79)
slide = prs.slides.add_slide(prs.slide_layouts[0])
slide.shapes.title.text = "Security operations, Q3"
slide.placeholders[1].text = "Board briefing"
slide = prs.slides.add_slide(TITLE_ONLY)
slide.shapes.title.text = "Phishing reports doubled after the training"
data = CategoryChartData()
data.categories = ["Jul", "Aug", "Sep"]
data.add_series("Reports", (120, 180, 260))
chart = slide.shapes.add_chart(
XL_CHART_TYPE.COLUMN_CLUSTERED, Inches(0.75), Inches(1.6), Inches(11.8), Inches(5.4), data
).chart
chart.has_legend = False
chart.plots[0].series[0].format.fill.solid()
chart.plots[0].series[0].format.fill.fore_color.rgb = ACCENT
slide.notes_slide.notes_text_frame.text = "Training launched July 14."
slide = prs.slides.add_slide(TITLE_ONLY)
slide.shapes.title.text = "Next steps"
body = slide.shapes.add_textbox(Inches(0.75), Inches(1.6), Inches(11.8), Inches(5)).text_frame
body.word_wrap = True
for index, line in enumerate(["Roll out to contractors", "Automate triage of reports"]):
paPreview of the first 4,000 characters. Read full instructions →
skill-creator5.51 KB
---
name: skill-creator
description: Write and improve 3B skills. Use when creating a new skill from scratch or refining an existing one — covers writing a description that triggers reliably, structuring clear instructions, and testing on realistic prompts.
license: Apache-2.0
compatibility: Tines 3B
---
# Writing a good skill
A 3B skill is an Agent Skills bundle the AI loads on demand. Each skill is a directory with a required `SKILL.md` and optional supporting files:
```text
my-skill/
├── SKILL.md
├── references/
│ └── api.md
├── assets/
│ └── report-template.md
└── scripts/
└── collect.ts
```
`SKILL.md` starts with YAML frontmatter. `name` and `description` are required. The name uses lowercase letters, numbers, and single hyphens, and it matches the parent directory. `license`, `compatibility`, string-valued `metadata`, and the experimental `allowed-tools` field are optional. `allowed-tools` is guidance, not a grant of 3B permissions. The body contains the instructions the AI reads once the skill is in play.
## The description is the trigger
The AI decides whether to consult a skill from its name and description alone, so this is the highest-leverage text you’ll write. Put _all_ the “when to use this” information here, not in the body. State both **what the skill does** and **the specific situations that should pull it in**.
AIs tend to under-trigger skills — to not reach for one when it would help. Counter that by being a little pushy and concrete. Instead of “Guidance for building dashboards,” write “Guidance for building dashboards. Use this whenever the request involves dashboards, data visualization, internal metrics, or displaying any kind of company data — even if the word ‘dashboard’ is never used.”
Note that simple, one-step requests may not trigger any skill, because the AI can just handle them directly. Skills earn their keep on complex, multi-step, or specialized tasks — write the description for those.
## Writing the instructions
- **Keep it focused.** Include what the AI can’t reliably infer on its own; cut throat-clearing. A tight, well-organized skill beats an exhaustive one.
- **Use the imperative.** “Read the API docs first,” not “The model should read the API docs.”
- **Define the output format** when it matters — give the exact template or structure you expect.
- **Show an example or two.** A concrete input → output pair teaches faster than a paragraph of rules.
- **Explain the why.** Today’s models have good judgment; tell them _why_ something matters and they generalize. Reserve hard “ALWAYS/NEVER” rules for genuine footguns — if you’re reaching for all-caps MUSTs, that’s usually a sign to reframe and explain the reasoning instead.
Keep `SKILL.md` focused on the workflow and decision points. Move detailed material or deterministic work into supporting files, and link to each supporting file from `SKILL.md` with clear guidance about when to use it.
## References, assets, and scripts
- **`references/`** contains documentation the AI should read only when it needs that detail: API notes, schemas, domain rules, or longer examples. Link directly from `SKILL.md`, and avoid chains where one reference points to another reference.
- **`assets/`** contains files used to produce the final output, such as templates, fixtures, images, or starter projects. Assets are available to copy or transform; they do not need to be loaded into context unless the task requires reading them.
- **`scripts/`** contains deterministic helpers for work that should not be regenerated on every use. Tell the AI what each script does, when to run it, what arguments or stdin it expects, and what it writes to stdout or files.
Use paths relative to the skill directory. Include static dependencies in the bundle, and state any runtime or package requirements in `SKILL.md` and `compatibility`.
3B runs shell (`.sh`), Python (`.py`), JavaScript (`.js`), and TypeScript (`.ts`) skill scripts through sandboxed execution. ThePreview of the first 4,000 characters. Read full instructions →
status-update723 Bytes
--- name: status-update description: Draft evidence-based status updates from recent work across the user’s connectors. Use for daily or weekly updates, project summaries, stakeholder notes, and progress reports. license: Apache-2.0 compatibility: Tines 3B --- # Status updates Gather the relevant work for the requested period before drafting. Organize the update around outcomes rather than activity: - What changed or shipped - Why it matters - What is in progress - Risks or blockers - Decisions or help needed - What happens next Use concrete names, links, and measurements where available. Do not invent progress from assignment alone. Match the audience and requested format, and keep routine updates concise.
tines-cases2.59 KB
---
name: tines-cases
description: Working with Tines Cases from a 3B workflow or chat — creating, updating, listing, and managing cases with their comments, subscribers, and activities, plus the Records store cases draw on. Use this whenever you’re asked to open, update, close, search, or manage a Tines case, to work with Tines records, or to call the Tines API for anything case- or record-related.
license: Apache-2.0
compatibility: Tines 3B
---
# Working with Tines Cases
Tines Cases is Tines’ investigation and case-management surface, and Records is the structured-data store alongside it. You reach both through the same **Tines Stories** connector (identifier `tines`) that covers the rest of the Tines API.
## Find the connector first
Before writing any call, use the `searchConnectors` tool with the identifier `tines` to find an existing “Tines Stories” connector. Reuse it if one exists. Only if none is found, prompt the user to create one with the `connectStepToApp` tool.
## Read the endpoint doc before you write the call
Payloads have non-obvious fields, so fetch the specific endpoint doc and follow it rather than guessing. The API index the connector points you at links a per-endpoint markdown doc for every case operation and sub-resource (comments, records, subscribers, activities, and so on), and for every record operation. For a conceptual overview of how Cases works, see `https://www.tines.com/docs/cases/overview/`.
Flag ambiguity rather than guessing silently.
## Records
Records are structured, queryable tables: a record type defines typed fields, and each record is a row of field values. They stand on their own, and a record can additionally be linked to one or more cases, e.g., when it’s evidence in an investigation. Records live under `records`, their schemas under `record_types`, and a case’s linked records under `cases/<case_id>/records`.
For a conceptual overview, see `https://www.tines.com/docs/records/`. Before writing record calls, read `https://www.tines.com/llm/stories/docs/api/records/best-practices.md` — it covers aggregate queries, pagination, filters, rate limits, retention, and linking records to cases.
## Base path
Cases and records live under `{TINES_URL}/api/…`. Prefer the newest API version an endpoint offers, and don’t fall back to an older version just because the connector’s connection test happens to hit one. Versions vary by endpoint — some case-related operations sit under the newer version while others are still on the older one — so check the endpoint doc for the current version of each call rather than assuming a single base path.
tines-export-to-3b29 KB
--- name: tines-export-to-3b description: Your guide to reading a Tines story export JSON and rebuilding it as a 3B workflow. Use this whenever you see a Tines export JSON, are asked to migrate or convert a Tines story to 3B, or hit Tines concepts like actions, Event Transformation, formulas, credentials, teams, or links and need the 3B equivalent in order to build it. license: Apache-2.0 compatibility: Tines 3B --- # Building a 3B workflow from a Tines export You'll be handed a Tines story as a JSON export and asked to rebuild it in 3B. This guide tells you, for each Tines piece, what to build in 3B and how. Treat it as a starting map, not gospel: some mappings are unproven, so when something looks ambiguous (especially formulas, dates, and type coercion), flag it rather than guessing silently. When a mapping uses a named volume for a queue, join, deduplication, delayed work, or retained files, use `workflow-volume-design` before choosing its file layout and schedule. ## Flag these up front (not portable / needs human input) - **5-minute (300s) per-step execution ceiling** — there's no way today to run a step longer than that, so long running steps or delays need to be considered up front and broken up (durable state in a volume + cron continuation). ## Always: write a migration report in the workflow README After building, document the migration in the workflow README. Cover: - **Link back to the original** - If the JSON export contains a `story_url` then include this at the top of the migration report as a hyperlink "View original story on Tines". - **What was migrated** — the Tines actions and how each maps to its 3B step. - **What changed shape** — anything that isn't a 1:1 port (fan-out → single-run loops, Implode → SQLite join, formulas → code), so the user knows where behavior may differ. - **What needs a human** — flag everything you couldn't fully reproduce or that needs the user to finish: e.g. agentic AI actions, missing credentials, anything where a formula/date/type-coercion translation is uncertain. - **What to double-check** — call out the silent-failure risks (missing fields, type coercion, cross-run dedup) so the user knows where to verify. - **Existing Tines dependencies** — any calls back to Tines for Resources / Records etc. This will be important for the customer if they look to ever decommission their Tines Stories infrastructure and move fully to 3B. Treat this report as a required deliverable, not optional polish — it's how the user audits a migration they didn't watch happen. ## The one thing to internalize first **3B has no per-event routing or fan-out.** Where Tines splits a list into N events and runs downstream steps once per event, you keep a **single run**: the array rides on stdin, and each step loops over it. The outputs match Tines, but two things differ — side effects must loop explicitly, and there's no per-event isolation. This pattern shows up in Explode, Condition, and no-match links, so get comfortable with it now. ## Resolving `META`, `INFO`, and `RESOURCE` references The JSON export may reference values using `META`, `INFO`, or `RESOURCE` as the top-level key. You can use the `references` field in the JSON export to find the value for such references (e.g. `META.tenant.domain`, `RESOURCE.my_resource`, etc). The` references` field acts as a key-value dictionary of references used in the story, where the key is the fully-qualified reference as it appears in the story. **IMPORTANT**: Note that for the references keyed with `RESOURCE`, the corresponding value is the **ID** of that resource, **NOT** the value of the resource. If you cannot find a value for a given reference, or the `references` field does not exist in the JSON export, add the missing references to your migration report as something that requires human input. ## Send to Story settings Inspect the story-level `send_to_story_enabled`, `entry_agent_guid`, `exit_agent_guids`, and `parent_only_send_to_story` pro
Preview of the first 4,000 characters. Read full instructions →
workflow-discovery912 Bytes
--- name: workflow-discovery description: Turn an automation idea into a clear workflow brief and practical design. Use when the user is starting a workflow, wants questions that clarify it, or wants workflow ideas based on their connectors. license: Apache-2.0 compatibility: Tines 3B --- # Workflow discovery Establish the workflow’s outcome before designing steps. Ask only for decisions that materially affect the implementation: - What event or schedule starts the work - What input is available - Which connectors and records are authoritative - What transformation or decision is required - What output or side effect marks success - How failures should be handled When suggesting ideas, ground them in connectors the user can actually use and favor repetitive, time-sensitive work with a clear measurable result. Produce a brief that is specific enough to build without restating the conversation.
workflow-operations1.21 KB
--- name: workflow-operations description: Add production operating behavior to a workflow. Use for schedules and event triggers, completion or failure notifications, targeted retries, operational logging, and follow-on automation. license: Apache-2.0 compatibility: Tines 3B --- # Workflow operations Add operating behavior from the workflow’s real reliability requirements: - Choose a schedule or event trigger that matches when the source data becomes ready. - Notify only people who can act, and include the workflow, run, outcome, and next action. - Retry transient operations with bounded attempts; surface permanent or exhausted failures. - Log stable identifiers and decisions needed to trace a run without recording secrets or redundant payloads. - Build follow-on automation as another composable workflow when it has an independent trigger, owner, or lifecycle. For scheduled work on named volumes, use `workflow-volume-design`. Keep each run bounded, keep input until the change that applied it is published, and verify that pending work drains faster than it arrives. A completed run alone does not establish that the schedule is keeping up. Run the workflow with representative input after changing its operating behavior.
workflow-review1.73 KB
--- name: workflow-review description: Explain, test, simplify, and improve an existing workflow. Use when reviewing behavior, finding edge cases or failure points, validating sample data, or improving reliability, clarity, and performance. license: Apache-2.0 compatibility: Tines 3B --- # Workflow review Read the workflow files and recent execution evidence before proposing changes. When the workflow uses named volumes or filesystem-backed state, use `workflow-volume-design` and inspect volume declarations, actual usage, and the steps on the common request path. Review the workflow as one program: 1. Explain its trigger, data flow, side effects, and result. 2. Test representative success, empty, malformed, duplicate, and dependency-failure inputs. 3. Identify failures that can be handled locally and failures that must remain visible. 4. Remove redundant work and simplify boundaries before adding retries or branches. 5. Run affected steps and tests after changes. For volume-backed workflows, check that frequent requests do not scan growing directories, mount unrelated state, or start unnecessary downstream executions. Check that every pair of writers to the same file is safe when one loses a volume conflict, that request steps report pending rather than success for writes that can still lose, that writers select bounded batches before scanning or parsing, retain input until derived changes are durable, and drain pending work under sustained input. Compare request latency, waiting executions, oldest pending age, and volume usage before and after a change. Prioritize concrete issues supported by code or execution results. Preserve intentional behavior, and do not add logging, retries, or abstractions without a specific failure they address.
workflow-volume-design15.8 KB
--- name: workflow-volume-design description: Design reliable 3B workflows that use named volumes or filesystem state. Use whenever a workflow stores or shares files, persists state across runs, receives concurrent requests, must let only one request win (bookings, reservations, claims, unique names, limited stock, or deduplication), keeps counters or shared records, uses an embedded database, handles uploads, builds reporting data, or needs temporary per-run files. license: Apache-2.0 compatibility: Tines 3B --- # Design workflows with volumes Use this skill before creating or changing steps that use named volumes or filesystem-backed state. Discover the workflow tools available in the current interface. For an existing workflow, inspect its step graph, source, volume declarations, schedules, recent runs, and volume usage before changing the design. Separate measurements from assumptions. Users describe the behavior they need, not a storage primitive. Choose file layouts, database formats, volume names, and mount options yourself. Ask only product questions that change the design, such as whether data must survive later Live runs, how fresh an answer must be, or how long records must be retained. Explain the resulting behavior in product terms. ## Core model A volume is a named POSIX directory mounted at `/storage/<name>`. In Live, every workflow in a space that declares the same name mounts the same committed files. Draft branches have isolated files. `scope=run` gives one workflow run its own volume, shared by steps in that run that declare the same name and scope. A `:ro` mount is read-only. A step reads the volume as it was committed when the step started and writes into a private view. Other steps see the last committed version, never its partial writes. A failed step discards its changes. A successful step publishes each volume separately and atomically, so files that must be committed together belong in one volume. Writable mounts do not lock. Two runs of the same step, different steps, or different Live workflows in the same space can write the same named volume at the same time. Run-scoped volumes are shared only by steps in one run, so separate runs do not write the same run-scoped volume. When a step publishes, 3B checks every file and directory entry the step created, changed, or deleted. If any of them changed after the step started, the publication fails with a volume conflict that names the volume and the file, the step fails, and none of its changes to that volume are saved. Overlapping runs that write different paths both publish. Two runs that create the same new file conflict just as two runs that edit it do, while two runs that create the same directory do not. So among overlapping runs that change the same file, at most one publishes. Only files a step writes are checked. A file it only read can change underneath it without a conflict. This is the coordination tool volumes provide, and the patterns below build on it. A routed step’s response reaches the caller before its volume changes publish. A request step therefore cannot promise its caller that a write was saved. When the caller needs the outcome, respond that the request is pending and let the caller read the published result. Linked downstream steps start only after the step’s changes publish, so send confirmations, notifications, and other side effects that depend on a write from a downstream step. Follow the [secret-storage prohibition](../building-workflows/SKILL.md#volumes). Use stdin and stdout for small handoffs between adjacent steps. Use volumes when steps need filesystem paths, many related files, random access, or data that survives a step. ## Choose a pattern by the guarantee Decide what the product must guarantee when requests overlap, then pick the matching pattern. Plain files support every pattern here. - **Independent records.** Submissions, events, uploads, and messages that never compete get a new unique path each, su
Preview of the first 4,000 characters. Read full instructions →
xlsx7.94 KB
---
name: xlsx
description: Create, edit, analyze, and read Excel spreadsheets (.xlsx, .xlsm, .csv) with XlsxWriter, openpyxl, and pandas. Use whenever the user wants a spreadsheet as output — a report, tracker, export, budget, or financial model — or uploads one to analyze, clean, reformat, or extend, even if they only say “sheet”, “Excel”, or “table”.
license: Apache-2.0
compatibility: Tines 3B
---
# Excel spreadsheets
Work with spreadsheets in Python through `execute`, adding packages to a `requirements.txt` in `files`: `XlsxWriter==3.2.9` to create workbooks, `openpyxl==3.1.5` to read and edit them, and `pandas` for analysis. In a workflow step, add them to the step’s `requirements.txt` instead.
User uploads arrive under `/3b/uploads/<id>/<file>`, which every execution can read. Write output to a persistent volume, such as `volumes: ["documents"]` and `/storage/documents/budget.xlsx`, then call `showStorageFile` so the user can preview it with sheet tabs and download it. Never overwrite the user’s upload: save edits as a new file, and call `showStorageFile` again after each change.
## Reading
Look before you parse. Real workbooks have title rows above the header, merged cells, hidden sheets, notes below the data, and several tables on one sheet.
```python
from openpyxl import load_workbook
wb = load_workbook("/3b/uploads/abc/vendors.xlsx", data_only=True)
for ws in wb.worksheets:
print(f"--- {ws.title} ({ws.sheet_state}) {ws.dimensions}, merged: {list(ws.merged_cells.ranges)[:5]}")
for row in ws.iter_rows(max_row=8, values_only=True):
print(row)
```
`data_only=True` returns the results Excel last saved for formula cells, and `data_only=False` returns the formulas themselves. Once you know where the header row is, load the data with pandas for analysis: `pd.read_excel(path, sheet_name="Vendors", header=2)`. Dates can arrive as Excel serial numbers and IDs as floats, so check `dtypes` before computing anything.
## Formulas need saved results
An xlsx file stores each formula next to its last result. Excel, Google Sheets, and Numbers recalculate when they open a file, but the 3B preview, pandas, and `data_only=True` only read the saved result. A formula saved without one shows as blank there, and a chart over those cells draws nothing.
So write every formula with its result. Compute the value in Python from the same data, and pass it to XlsxWriter’s `write_formula` as `value=`, naming the argument because the positional slot before it is the cell format. Without it, XlsxWriter saves 0, and the preview shows zeros until someone opens the file in a spreadsheet app. Use formulas wherever a person may change inputs, such as totals, lookups, and model outputs, so the workbook stays live, and write plain values for figures nobody will edit.
## Creating
Create new workbooks with XlsxWriter:
```python
import datetime
import xlsxwriter
vendors = [
("Okta", "Identity", 42000, datetime.date(2026, 11, 15)),
("CrowdStrike", "Endpoint", 88000, datetime.date(2027, 3, 31)),
("1Password", "Identity", 18500, datetime.date(2026, 10, 31)),
]
last = len(vendors) + 1
wb = xlsxwriter.Workbook("/storage/documents/vendors.xlsx")
money = wb.add_format({"num_format": '"$"#,##0'})
total_money = wb.add_format({"num_format": '"$"#,##0', "bold": True})
bold = wb.add_format({"bold": True})
ws = wb.add_worksheet("Vendors")
ws.add_table(0, 0, last - 1, 3, {
"name": "Vendors",
"style": "Table Style Medium 2",
"columns": [
{"header": "Vendor"},
{"header": "Category"},
{"header": "Annual cost", "format": money},
{"header": "Renewal", "format": wb.add_format({"num_format": "yyyy-mm-dd"})},
],
"data": [list(vendor) for vendor in vendors],
})
ws.set_column("A:B", 18)
ws.set_column("C:D", 14)
ws.freeze_panes(1, 0)
ws.write(last, 0, "Total", bold)
ws.write_formula(last, 2, f"=SUM(C2:C{last})", total_money, value=sum(v[2] for v in vendors))
summary = wb.add_worksheet("SummPreview of the first 4,000 characters. Read full instructions →
Release notes
Initial release with the complete Tines 3B skills collection and tenant-scoped MCP access for building, running, monitoring, and governing workflows.
Declared in the saved package. Remote tools may change independently.
Package details
Publisher declarations from the archived package. These are separate from our research and the live service's terms.
- Package author
- Tines
- Keywords
- See keywords
- Commerce declaration
- Does not support commerceThis does not establish whether access is free or paid.
- Review scenarios
- 5 positive · 3 negativeScenario counts, not test results.
Declared capabilities
- Explore spaces and workflows
- Build and improve workflows
- Run workflows and inspect executions
- Monitor workflow health and AI usage
- Govern access, dependencies, and spend
Package observed Nov 17, 2026.
Technical details
- First seen
- Nov 17, 2026 · 12:00 UTC
- Last seen
- Nov 17, 2026 · 12:00 UTC
- Collection status
- Collected
plugins_6af4333b6f008191806d76e5f43ec5f9
Download plugin data (JSON)Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.