Chat Agent & Agent Studio¶

Thinklio Built-in Agent Specification Version 0.2 | March 2026

1. Chat Agent¶

1.1 Purpose¶

The Chat Agent is the general-purpose conversational assistant — the simplest agent in the catalogue and, for many users, the starting point. It has no fixed domain, no curated library, no specialist tools. It is a capable, knowledgeable conversational partner with access to the workspace's knowledge layers and, optionally, web search and document analysis.

Its apparent simplicity is its value. Users who don't need the specific capabilities of a specialist agent — who just want to ask questions, think through problems, draft things, or get help with whatever is in front of them — use the Chat Agent. It should not feel like a reduced version of something else. It is a complete, well-executed general-purpose assistant.

It is also the default agent — the one a new user encounters before they have configured anything else. The first impression of Thinklio for most users is the Chat Agent.

1.2 UI Structure¶

[ Chat ]

The Chat Agent is the only agent in the catalogue with a single-tab UI. This is deliberate. A second tab would imply structure that does not exist. The chat interface is the product.

1.3 Agent Capabilities¶

Capability	Description
Conversation	Open-ended dialogue on any topic
Drafting	Write emails, documents, messages, plans, summaries — any text
Analysis	Analyse text, data, arguments, and situations provided in conversation
Problem-solving	Think through decisions, generate options, evaluate trade-offs
Research (via web search)	Search the web for current information (if tool enabled)
Document analysis	Read and analyse documents provided by the user (if tool enabled)
Knowledge retrieval	Answer questions using the workspace's knowledge layers
Code	Write, explain, and debug code
Translation	Translate between languages
Calculation	Perform mathematical and logical operations

1.4 Knowledge Layer Access¶

The Chat Agent accesses the workspace's knowledge layers in the same way as any other agent. In a team context, it is aware of team knowledge. It remembers what the user has told it across sessions. It applies the workspace's org voice profile if configured.

This is what distinguishes a workplace Chat Agent from a generic AI assistant: it knows the context. It knows the company. It knows the user's projects and preferences. It is not starting from zero every time.

1.5 What the Chat Agent is Not¶

It does not take actions on external systems without the relevant specialist agents configured as delegates
It does not have access to live data feeds without the Monitor Agent or Digest Agent
It is not a replacement for specialist agents when specialist capability is genuinely needed — it should recognise when a user's need would be better served by a specialist and say so directly: "I can help you draft the report, but for properly sourced academic research the Research Agent would do this much better — would you like me to kick that off?"

1.6 Configuration¶

Setting	Description
Web search enabled	Whether the agent can search the web
Document tools enabled	Whether the agent can read uploaded documents
Persona name	Custom name for the agent in this deployment
System prompt supplement	Additional instructions layered on top of the default
Delegate agents	Other agents this Chat Agent can invoke

1.7 Use Cases¶

UC-1: General assistance A user asks for help structuring a difficult conversation with a team member who has been missing deadlines. The agent engages in thoughtful dialogue — asking about context, suggesting frameworks, helping draft key talking points. No tools, no delegation. A capable thinking partner.

UC-2: Document review A user uploads a contract and asks the Chat Agent to summarise the key obligations and flag unusual clauses. The agent reads the document, produces a structured summary, and notes two clauses worth reviewing with a lawyer. It does not give legal advice — it assists the user in understanding what they are reading.

UC-3: Delegation handoff A user asks the Chat Agent to research the competitive landscape for podiatry software in Australia. The Chat Agent recognises this as a task suited to the Research Agent, explains briefly, and offers to invoke it. The user agrees. The Chat Agent delegates and reports back when the research is complete.

2. Agent Studio¶

2.1 Purpose¶

Agent Studio is the workspace where Thinklio users compose, configure, and deploy custom agents. It is not an agent itself — it is the product interface that makes the agent composition model accessible to non-technical users.

The platform's delegation and coordination architecture is powerful but inherently complex. Agent Studio's job is to make that complexity manageable: to let a team lead build a "Project Coordinator with Research and Scheduling" without understanding how job dispatch, delegation chains, or capability levels work under the hood.

It is the creative tool of the Thinklio platform.

2.2 UI Structure¶

[ Studio ]  [ Deployed ]  [ Templates ]

Studio Tab: The workspace for building a new agent or editing an existing one.

Deployed Tab: All custom agents deployed in this workspace, with status, usage statistics, and edit access.

Templates Tab: Pre-built templates from Thinklio and any templates the org has created and saved.

2.3 The Studio Canvas¶

The Studio canvas has two panels: the Configuration Panel (left) and the Delegation Graph (right).

Configuration Panel defines the agent across six sections, each accessible as a collapsible panel:

Identity — name, description, persona and tone
Capability — capability level (tools only / workflow / learning), system prompt
Knowledge — active knowledge layers, library assignments, seeded facts
Tools — built-in tool assignments (web search, document reading, etc.)
Skills — named sub-capabilities the agent exposes (see section 2.5)
Governance — budget limits, usage restrictions, content policies, UI tab configuration

Delegation Graph defines the agent's delegates. A visual graph with the current agent at the centre and delegate agents connected by edges.

Adding a delegate: drag from the catalogue or workspace agent list onto the canvas
Configuring a delegation: click the edge to set per-delegation restrictions, parameters, and execution mode (immediate or deferred)
Depth limit: shown visually; red indicator if the workspace limit is exceeded
Cycle detection: circular dependencies are highlighted immediately and blocked from saving

2.4 Building an Agent — Workflow¶

1. Start: new agent or from template
2. Identity: name, description, persona
3. Capability: capability level, system prompt (guided or freeform)
4. Knowledge: libraries, knowledge layer access, seeded facts
5. Tools: assign built-in tools
6. Skills: define named sub-capabilities (optional)
7. Delegates: add agents from catalogue or workspace
8. Configure per-delegation restrictions for each delegate
9. Preview: test in sandboxed chat interface
10. Deploy: publish to self, team, or workspace

Steps 6, 7, and 8 are optional. A simple knowledge agent needs none of them.

3. Skills¶

3.1 What Skills Are¶

A skill is a named, parameterised, output-typed sub-capability of an agent — a pre-configured operation that can be invoked explicitly by a user or a coordinating agent, producing a consistent and predictable result.

Skills sit inside agents. They are not a separate tier between tools and agents. They are named invocation patterns on top of an agent's underlying capability, each with:

A defined prompt template (pre-packaging the prompt engineering for that operation)
A typed parameter schema (what inputs the skill accepts)
A defined output schema (what the skill reliably returns)
Explicit invocability (by users, by coordinator agents, or both)

The difference between a skilled agent and an unskilled agent is predictability and composability. Without skills, a coordinator asking for "an executive summary" describes what it wants in natural language and hopes for consistent output. With a summarise.executive skill, it calls a named operation and receives a reliably formatted result every time.

3.2 The Three-Layer Capability Model¶

Skills clarify the relationship between the three tiers of agent capability:

Tools
└── Deterministic, code-based operations
    Examples: calendar lookup, database query, API call, file read
    Characteristics: fast, cheap, no LLM involved, fully predictable

Skills
└── Prompt-based, judgement-requiring operations — reusable within an agent
    Examples: summarise, extract, classify, compare, quiz, flag
    Characteristics: LLM-based, consistent via prompt template, typed I/O

Agents (delegation)
└── Domain work with persistent state, knowledge layers, multi-step reasoning
    Examples: Research Agent, Writer Agent, Fact Checker Agent
    Characteristics: heavyweight, stateful, appropriate for substantive work

Skills fill the gap between tools (too simple) and full agent delegation (too heavy) for prompt-based operations that are used repeatedly within an agent's function.

3.3 Skill Anatomy¶

AgentSkill
├── skill_id            UUID
├── agent_id            UUID (the agent this skill belongs to)
├── name                string (namespaced: "summarise.executive")
├── display_name        string ("Executive Summary")
├── description         string (what this skill does and when to use it)
├── prompt_template     string (the pre-configured prompt; supports parameter interpolation)
├── parameters[]
│   ├── name            string
│   ├── type            enum (string | integer | enum | boolean | document)
│   ├── required        boolean
│   └── default         any | null
├── output_schema
│   ├── type            enum (text | structured | list | boolean)
│   └── description     string
├── invocable_by        enum (user | agent | both)
├── created_by          enum (platform | org | user)
└── version             string

Prompt template interpolation allows skill parameters to be injected into the template at invocation time:

Template: "Summarise the following document for a senior executive audience 
in no more than {{max_words}} words. Focus on {{focus_area}}. 
Return only the summary, no preamble.\n\n{{document}}"

Parameters: max_words (integer, default: 150), focus_area (string, default: "key decisions and implications"), document (document, required)

The calling agent or user provides the parameters; the skill assembles the final prompt and executes it against the agent's underlying model.

3.4 Skill Scopes¶

Skills exist at three scopes, mirroring the knowledge layer model:

Platform skills — built in by Thinklio, available on built-in agents, maintained and versioned by the platform. These represent the canonical implementations of common operations.

Org skills — defined by workspace admins in Agent Studio for custom agents. Encode organisation-specific operations that recur frequently enough to warrant formalisation.

User skills — defined by individual users on their personal agents. Lightweight personal automations — a specific output format the user always wants, a classification scheme they use repeatedly.

3.5 Platform Skill Examples¶

The following illustrate the range of what platform skills look like on built-in agents. This is not an exhaustive list — it is indicative.

Summarisation Agent skills:

Skill name	What it produces
`summarise.executive`	One paragraph, decision-relevant points only, senior audience
`summarise.detailed`	Full structured summary with section headings
`summarise.bullet`	Configurable-count bullet points
`summarise.tldr`	Single sentence
`summarise.changelog`	What changed relative to a previous version of the same document
`summarise.quiz`	5–10 comprehension questions that test understanding of the document
`summarise.glossary`	Definitions of key terms used in the document
`summarise.actions`	Action items and commitments extracted from the document

Writer Agent skills:

Skill name	What it produces
`write.headline`	Single headline for a piece of content
`write.social`	Platform-specific social media post (parameter: platform)
`write.subject_line`	Email subject line options (parameter: count)
`write.cta`	Call-to-action variants (parameter: tone, count)
`write.expand`	Expand a bullet point or short passage into full prose
`write.condense`	Condense a passage to a target word count

Research Agent skills:

Skill name	What it produces
`research.quick`	Fast overview from top sources, citation-summary level
`research.deep`	Full research run, facts-list level
`research.news`	Recent news only, date-range configurable
`research.cite`	Formatted citation list for a given source list

Fact Checker Agent skills:

Skill name	What it produces
`check.factual`	Factual accuracy only — claims vs. sources
`check.citations`	Citation integrity only
`check.voice`	Voice and style compliance only
`check.full`	All checks combined

Data Agent skills:

Skill name	What it produces
`data.to_csv`	Convert source list or structured output to CSV
`data.to_table`	Convert to a formatted markdown table
`data.top_n`	Return top N results by a specified field
`data.diff`	Diff two datasets and return net-new items

Scribe Agent skills:

Skill name	What it produces
`scribe.summary`	Meeting summary from transcript
`scribe.actions`	Action items only, structured
`scribe.decisions`	Decisions made, structured
`scribe.questions`	Open questions raised but not resolved
`scribe.full`	Complete structured meeting output

3.6 Skills in Coordinator Agents¶

Skills are particularly powerful in coordinator agents, where consistency of output from specialist delegates determines the quality of the assembled result.

Without skills, the newsletter coordinator agent tells the Writer Agent: "please write a 600-word feature article in org voice with image placeholders." It hopes for a consistent result. With skills, it calls write.feature(word_limit=600, voice=org, image_placeholders=true) and receives a reliably structured draft every time.

This makes coordinator prompt engineering simpler and coordinator behaviour more predictable — the coordinator specifies what it wants precisely, rather than hoping natural language instructions are interpreted consistently.

3.7 Skills in the Agent Studio UI¶

When a user opens the Skills section of the Configuration Panel:

For built-in agents: Platform skills are shown as a read-only list. For each skill, the user can see its name, description, parameters, and output schema. Per-assignment, individual skills can be enabled or disabled (e.g. a team deployment of the Writer Agent might disable write.social if the team does not produce social content).

For custom agents: The user can define new org skills or user skills using a guided form:

Name the skill (namespaced under the agent: myclassifier.by_project)
Write the prompt template (with a parameter interpolation helper)
Define parameters (name, type, required, default)
Define the output schema (what does this skill return?)
Set invocability (user-invokable, agent-invokable, or both)
Test it: run the skill against a sample input and review the output
Save

The skill is immediately available for use in preview mode and after deployment.

Skill invocation in chat: Users can invoke a skill explicitly by name in the chat interface: "Use the executive summary skill on this document." Or they can select it from a skills palette — a small toolbar that appears when a document is attached, showing available skills for that input type. The palette surfaces the most relevant skills contextually (document attached → summarisation skills appear; text pasted → writing skills appear).

Skill invocation by coordinators: Coordinator agents call skills programmatically via the agent-as-tool interface. The skill name and parameters are part of the invocation schema, treated the same way as tool parameters. The coordinator receives the typed output and continues its reasoning.

3.8 Skills and Templates¶

When an agent is saved as a template, its skills are included. A user deploying a template gets all the skills the template author defined, ready to use immediately.

This is particularly valuable for org templates distributed across teams: an org-defined Document Intelligence Agent template might come with five pre-configured extraction skills that encode the organisation's specific document processing needs. Every team that deploys the template gets those skills without having to define them.

3.9 Skill Versioning¶

Skills are versioned. When a platform skill is updated (improved prompt, new parameters, changed output schema), agents using that skill are notified. The workspace admin can:

Update to the new version immediately
Test the new version in preview before updating
Pin to the current version if the existing behaviour is working well

This prevents skill updates from silently changing agent behaviour in production.

4. The Coordinator Pattern¶

For users building coordinator agents, Agent Studio provides a guided coordinator mode:

Define the coordinator's purpose and scope
Select specialist delegates from the catalogue
For each delegate, optionally select which skills the coordinator will invoke (rather than leaving it to free-form delegation)
Define the coordinator's orchestration logic (in natural language, translated to a system prompt)
Configure per-delegation restrictions for each specialist
Set up the UI — the Today tab, Board tab, or other structured views as appropriate

The skills selection in step 3 is new. Rather than the coordinator describing what it wants from each delegate in its orchestration prompt, it can specify named skills — making the coordination both simpler to author and more reliable to run.

5. Preview Mode¶

Before deploying, the user can preview the agent in a live sandbox: - Chat interface for conversation testing - Skills palette visible — individual skills can be tested in isolation - Tool calls and delegations shown transparently - Skill invocations shown with the interpolated prompt and raw output, for debugging - Any errors surface here before deployment

Preview mode is sandboxed — agents with send permissions do not send actual messages.

6. Deployment Options¶

Option	Description
Assign to self	Available only to the creator
Assign to team	Available to all members of a specified team
Assign to workspace	Available to all workspace members
Restricted access	Available to specific named users

Deployment creates an AgentAssignment per scope. The creator can manage assignments after deployment. Per-assignment skill enabling/disabling is available — specific skills can be turned off for specific deployment contexts without changing the agent configuration.

7. Templates¶

Platform templates (from Thinklio): all agents in the starter catalogue plus common custom configurations. Include platform skills by default.

Workspace templates (created by org admins): custom agents saved for reuse across teams. Include all skills defined by the template author.

A template captures: system prompt, capability level, tool assignments, skill definitions, delegation relationships, knowledge configuration, and UI tab configuration. It does not capture user-specific settings or credentials.

8. Governance at Deployment Time¶

When an agent is deployed, the platform checks: - Capability level is within the org's permitted range - Tool access does not exceed what the deploying user is permitted to grant - Skill definitions do not reference data the deploying user cannot access - Delegation depth is within the workspace limit - No circular delegation chains - Required fields are populated

The deploying user cannot grant an agent permissions they do not themselves have.

9. Usage and Monitoring¶

The Deployed tab shows per agent: - Total interactions (last 7 / 30 / 90 days) - Active users - Most common request types - Skill usage breakdown (which skills are invoked most, which are never used) - Cost usage vs. budget - Error rate (failed steps, failed delegations, failed skill invocations) - Any active alerts from Monitor Agent

The skill usage breakdown is new — it tells the agent author whether their defined skills are actually being used, and which ones are most valuable. Unused skills are candidates for removal; heavily used skills are candidates for refinement or promotion to platform level.

10. Open Questions¶

Chat Agent¶

Should the Chat Agent proactively suggest delegation to a specialist agent when it detects a more appropriate handler? An opt-in "suggest specialist agents" setting may be the right balance between helpful and intrusive.
Should the Chat Agent expose skills? Its general-purpose nature argues against fixed skills — it would essentially be duplicating the capabilities of specialist agents. But user-defined skills on the Chat Agent (personal shortcuts for operations the user does frequently) could be valuable.

Agent Studio¶

The canvas-based interface is a significant UI build. Is a simpler form-based interface sufficient for an initial release, with the visual graph deferred to a later phase?
The skills palette in the chat interface (contextually surfacing relevant skills when a document is attached, etc.) requires the UI to understand input types. How is this inference handled?
Natural language orchestration logic in coordinator mode — does the platform attempt to validate that the orchestration prompt maps to valid delegation patterns, or is this left to the user?
Template sharing and the marketplace model: the governance around what gets into the platform template catalogue needs defining.

Skills¶

Should skills have their own cost model? A skill invocation is a lighter-weight LLM call than a full agent interaction. Should it be billed differently?
Platform skill updates and version pinning: what is the notification mechanism for workspace admins when a platform skill changes?
Can a coordinator agent define skills at runtime — generating a skill invocation schema on the fly based on the task — or are skills always pre-defined? Runtime skill generation would be powerful but introduces unpredictability.
Should org skills be shareable between workspaces (like templates) or strictly private to the org that defined them?

Previous document version: 0.1. Skills model added in version 0.2.