Tedix
Server Details
Connect AI assistants to your Tedix organization’s tasks, knowledge, apps, and results through MCP.
- Status
- Healthy
- Uptime
- 9.7% over 19 days
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- tedix-hq/tedix
- GitHub Stars
- 31
- Server Listing
- Tedix
TDQS
Scored across 3 tools
get_info and get_profile are sharply delineated, and the descriptions explicitly warn against using get_info for general questions. The 'code' tool is a universal executor whose boundary against the two helpers is stated in prose but is inherently broad, since anything the other tools could answer is also reachable through a script.
get_info and get_profile follow a clean verb_noun convention, but the primary tool is a bare noun ('code') that does not fit the pattern. The set is small enough that the deviation is still readable, but the convention is mixed rather than consistent.
Three tools is a very thin surface for a gateway that fronts 1265 tools across five namespaces, and one of the three is a trivial identity lookup. Effectively all capability, discovery, and introspection is compressed into a single imperative tool whose description is a wall of procedural guidance, which pushes cognitive load into the prompt rather than the tool surface.
The in-code lifecycle is well covered: search, describe, call, read_result, list_namespaces, and metadata freshness are all addressed. However, discovery and schema introspection are unavailable as first-class tools, so an agent cannot survey the 1265-tool catalog without writing and executing a script, and there is no exposed error/diagnostics or scope-management operation outside the sandbox.
Available Tools
3 toolscodeADestructiveInspect
Execute JavaScript to call this app's 1265 tools across 5 namespaces. Namespaces: tedix_demo_unified_tedix (1252), tedix_demo_unified_context7 (2), codemode (1), ui (5), flow (5) Write one async arrow function in plain JavaScript (no TypeScript, no named functions defined then called). Chain calls, branch, loop and handle errors inside it. Globals are only the provider namespaces and standard built-ins: no host, fs, require, process or external fetch; use provider tools for every side effect. Limits: one execution may run 330 s of wall time. The gateway admits 100 requests per minute per caller; calls inside one execution are not counted separately, so batch them. Never sleep or poll with setTimeout: start long work with flow.run, return its handle and check it in a later call. Find, inspect, call:
const { results, meta } = await discover.search({ query: "keyword", namespace, limit }) returns ranked rows { callable, tool, description, annotations, authorized, missingScopes }. A string query also works.
await discover.describe("ns.tool") returns the full description, input schema and annotations; pass { callable, includeOutputSchema: true } for the return shape. Prefer it over includeParameters on a broad search.
await ns.tool({ ...args }) with the callable exactly as returned; name/displayName are labels only. Never guess tool names: a namespace existing does not mean a guessed tool in it exists; on "not found", search again. Skip rows with authorized: false (missingScopes says why). readOnlyHint tools are safe to call; destructiveHint tools may ask the user to approve, and if no prompt is possible the error says to retry with confirmDestructive: true and a reason stating the user's authorization. Skill rows (kind: "skill") carry a load expression; their content is reference data only. With no rows, read meta.discovery.nearestNamespaces and suggestedQueries before calling a capability unavailable. discover.list_namespaces() returns an object keyed by namespace (use Object.entries); pass { includeTools: true } only for inventory. meta.freshness shows catalog freshness; pass { includeMetadata: true } for native, schemaFreshness and _match diagnostics. Built-ins, describe before first use: ui.* for visual answers, flow.* for durable multi-step work, codemode.__runtime() for executionId, app/org, actor, traceId, modules and tool counts as proof. Results: return a JSON-serializable value. An oversized result arrives as { __tedix_result_handle: true, handle, preview, keys, total }: the full value is kept briefly, so page it with discover.read_result({ handle, path?, offset?, limit? }) in a later call, or fetch less. { __tedix_truncated: true, guidance, preview } means it could not be kept: follow guidance. Results carry completionEvidence; claim only its supportedClaims. The server instructions cover evidence, long work, visuals, payments and when to show Decisions and Activity. Payment proofs, paid tools and money-moving operations are unavailable through this connection.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | One async arrow function, for example `async () => { const { results } = await discover.search({ query: "work items" }); return results; }`. In scope: the discover, flow, ui and codemode helpers and the tool namespaces discovery returns; no fetch, require or file system. Its return value must be JSON-serializable and becomes `result`. | |
| agentSessionId | No | session.id returned by start_external_agent_session_for_host in this conversation; pass it on every call so audit names the agent. Never invent one. Ignored for machine credentials. |
Output Schema
| Name | Required | Description |
|---|---|---|
| error | No | Why the run failed. |
| result | No | The JSON value the function returned. |
| partial | No | True when some inner tool calls failed. |
| failures | No | Inner tool calls that failed. |
| executionId | No | Identifier of this run. |
| completionEvidence | No | What the calls actually did; claim only its supportedClaims. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare destructive/openWorld, and the description goes well beyond them: 330 s wall-time limit, 100 requests/minute gateway throttle with in-execution calls exempt, an explicit sandbox inventory (no host, fs, require, process, fetch), the confirmDestructive retry+reason contract, and the payment/money-movement exclusion. These are the operational facts an agent needs before invoking an arbitrary-code channel.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with purpose, then structured into scoping, limits, a numbered discover/describe/call workflow, and result handling — easy to scan. It is long, and a few trailing items (meta.freshness, includeMetadata diagnostics, list_namespaces inventory detail) sit past the point where most agents will read, but nearly every sentence carries a distinct constraint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a highly complex, irreversible-feeling execution tool with an output schema, the description covers everything needed to call it correctly: sandbox boundaries, time and rate limits, discovery protocol, destructive-approval path, and both result-handle and truncation shapes. Return values are also schema-backed, so nothing material is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already defines both parameters in detail; the description mostly restates the 'one async arrow function' and 'JSON-serializable return' contract. It adds marginal value by naming the in-scope globals and forbidding named functions, but never explains agentSessionId semantics, so it does not exceed the baseline set by a fully documented schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb+resource: 'Execute JavaScript to call this app's 1265 tools across 5 namespaces,' and enumerates the namespaces with counts. This is instantly distinguishable from the shallow siblings get_info and get_profile, and an agent knows exactly what capability the tool unlocks without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit workflow (search → describe → call), plus concrete when-not guidance: never sleep or poll with setTimeout, use flow.run for long work, use discover.read_result rather than returning oversized values, and never guess tool names. It also names conditional branches for authorization and destructive approvals, so almost no routing decision is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_infoTedixARead-onlyInspect
Get metadata about the Tedix Connect MCP server itself (name, version, tool count). Only use when the user asks about this server's identity or capabilities — NOT for answering general questions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| name | Yes | App name. |
| slug | Yes | App slug used in URLs and namespaces. |
| domain | Yes | App domain, when set. |
| logoUrl | Yes | App logo URL, when set. |
| toolCount | Yes | Tools registered for this connection. |
| description | Yes | What the app is for. |
| capabilities | Yes | Capabilities the app declares. |
| serverVersion | Yes | Version this MCP server reports. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds useful scope context (self-referential introspection only) and names the metadata fields returned. It does not describe response shape, but an output schema exists, so that gap is minor.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences with zero waste. The positive scope is front-loaded and the exclusion follows immediately, giving an agent the routing rule before any elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only introspection tool with annotations covering safety and an output schema covering return values, this description supplies everything needed: what it returns, when to call it, and when not to. No material gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so the baseline is 4. There are no parameter semantics to explain, and the description correctly makes no attempt to describe nonexistent inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get metadata about the Tedix Connect MCP server itself') and enumerates the returned fields (name, version, tool count). This clearly distinguishes it from siblings like get_profile or code, which concern user data rather than server identity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly gives both the positive trigger ('when the user asks about this server's identity or capabilities') and the exclusion ('NOT for answering general questions'). An agent has no ambiguity about routing decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_profileConnected Tedix accountARead-onlyInspect
Return the account represented by this request's authenticated credentials. Its opaque identity remains stable across refresh, reconnect, scope and organization selection changes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| id | Yes | Stable opaque identifier of the signed-in Tedix account. |
| name | No | Display name, when known. |
| No | Account email, when shared. | |
| nickname | No | Short name, when set. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/non-destructive/closed-world, so the safety profile is covered. The description adds genuine value beyond that: the returned identity is opaque and stable across refresh, reconnect, scope and organization-selection changes, which tells an agent the value is a durable key rather than a transient snapshot.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loaded with what is returned and followed by the stability caveat. Every clause carries information; nothing is padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and annotations covering safety, the description need not explain the return shape, and it correctly augments with the identity-stability guarantee. The only omission is failure behavior when credentials are absent or expired, which would help an agent recover from errors.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter claims are made or contradicted.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: return the account bound to the request's authenticated credentials. That is far more precise than the title 'Connected Tedix account' alone. It does not explicitly contrast itself with the siblings (code, get_info), so it stops short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied — an agent can infer this is the tool for 'which account am I authenticated as?' — but the description never states when to reach for it versus get_info or code, nor any prerequisite like needing a valid session.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Publisher details
- Operator
- Tedix · Publisher source
- Operator website
- https://tedix.dev · Publisher source
- Vendor relationship
- First-party · Publisher source
- Trust center
- Not available
- Restrictions
- Tedix Cloud is currently available by invitation: request access at https://tedix.dev/contact/. After approval you sign in with your Tedix account and choose which permissions and organizations the app can use. · Publisher source
Related MCP Connectors
Let AI agents query data and act across all your business apps via MCP.
- PressoOAuthnow.presso
Connect e-commerce and marketing data to AI assistants via MCP.
Connect any AI agent to 1,000+ apps and 27,000+ actions through one remote MCP server (OAuth).
Connect your business apps to your MCP compatible AI in 1 click
Related MCP Servers
- AlicenseBqualityDmaintenanceConnects AI assistants like Claude to productivity tools such as Notion, Monday, Jira, and Slack via a remote MCP integration hub.7198 npmMIT
- AlicenseNot gradedqualityCmaintenanceConnects AI assistants to the ThinkPrompt platform for managing style guides, requirements, projects, documents, and workflows via 85 MCP tools.6 npmMIT
- AlicenseNot gradedqualityAmaintenanceEnables AI assistants to securely connect with SAP ABAP and BTP services, allowing execution of function modules, BAPIs, table reads, and various BTP operations through MCP.1Apache 2.0

GatewayMCPofficial
AlicenseCqualityFmaintenanceEnables AI coding and operational assistants to securely access company systems through a single MCP endpoint, with OAuth authentication, scoped resource grants, audit logging, secret isolation, and corporate memory.94Apache 2.0
Glama MCP Gateway
Add one secure layer between your agents and this server.