Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Get Started Free →

Telnyx Video - Go · team-telnyx | DecimalAI

team-telnyx/telnyx-video-go

SkillScore91Maintained

Create and manage video rooms for real-time video communication and conferencing. This skill provides Go SDK examples.

codingby team-telnyx

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/team-telnyx-telnyx-video-go/SKILL.md

decimalai skills pull team-telnyx-telnyx-video-go --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/team-telnyx-telnyx-video-go/SKILL.md https://app.decimal.ai/s/team-telnyx-telnyx-video-go/SKILL.md

Raw file: /s/team-telnyx-telnyx-video-go/SKILL.md ↗ · machine-readable summary at /s/team-telnyx-telnyx-video-go.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

22 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 7d ago

Yes — +68% lift · at higher cost+210% tokens0% turns91% of whole cases pass with skill (20/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-01	✗→✓	▲ Improved	147%	0%
case-02	✗→✓	▲ Improved	162%	0%
case-03	✗→✓	▲ Improved	200%	0%
case-04	✗→✓	▲ Improved	203%	0%
case-05	✗→✓	▲ Improved	196%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/3/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

team-telnyx / ai

skills/telnyx-video-go/SKILL.md

View on GitHub ↗

License MITImported 8/10/2026Version v1

Skill contents

SKILL.md

Telnyx Video - Go

Installation

bash
go get github.com/team-telnyx/telnyx-go

Setup

go
import (
  "context"
  "fmt"
  "os"

  "github.com/team-telnyx/telnyx-go"
  "github.com/team-telnyx/telnyx-go/option"
)

client := telnyx.NewClient(
  option.WithAPIKey(os.Getenv("TELNYX_API_KEY")),
)

All examples below assume client is already initialized as shown above.

Error Handling

All API calls can fail with network errors, rate limits (429), validation errors (422), or authentication errors (401). Always handle errors in production code:

go
import "errors"

result, err := client.Messages.Send(ctx, params)
if err != nil {
  var apiErr *telnyx.Error
  if errors.As(err, &apiErr) {
    switch apiErr.StatusCode {
    case 422:
      fmt.Println("Validation error — check required fields and formats")
    case 429:
      // Rate limited — wait and retry with exponential backoff
      fmt.Println("Rate limited, retrying...")
    default:
      fmt.Printf("API error %d: %s\n", apiErr.StatusCode, apiErr.Error())
    }
  } else {
    fmt.Println("Network error — check connectivity and retry")
  }
}

Common error codes: 401 invalid API key, 403 insufficient permissions, 404 resource not found, 422 validation error (check field formats), 429 rate limited (retry with exponential backoff).

View a list of room compositions.

GET /room_compositions

go
	page, err := client.RoomCompositions.List(context.Background(), telnyx.RoomCompositionListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: completed_at (date-time), created_at (date-time), download_url (string), duration_secs (integer), ended_at (date-time), format (enum: mp4), id (uuid), record_type (string), resolution (string), room_id (uuid), session_id (uuid), size_mb (float), started_at (date-time), status (enum: completed, enqueued, processing), updated_at (date-time), user_id (uuid), video_layout (object), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

Create a room composition.

Asynchronously create a room composition.

POST /room_compositions

Optional: format (string), resolution (string), session_id (uuid), video_layout (object), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

go
	roomComposition, err := client.RoomCompositions.New(context.Background(), telnyx.RoomCompositionNewParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", roomComposition.Data)

Returns: completed_at (date-time), created_at (date-time), download_url (string), duration_secs (integer), ended_at (date-time), format (enum: mp4), id (uuid), record_type (string), resolution (string), room_id (uuid), session_id (uuid), size_mb (float), started_at (date-time), status (enum: completed, enqueued, processing), updated_at (date-time), user_id (uuid), video_layout (object), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

View a room composition.

GET /room_compositions/{room_composition_id}

go
	roomComposition, err := client.RoomCompositions.Get(context.Background(), "5219b3af-87c6-4c08-9b58-5a533d893e21")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", roomComposition.Data)

Returns: completed_at (date-time), created_at (date-time), download_url (string), duration_secs (integer), ended_at (date-time), format (enum: mp4), id (uuid), record_type (string), resolution (string), room_id (uuid), session_id (uuid), size_mb (float), started_at (date-time), status (enum: completed, enqueued, processing), updated_at (date-time), user_id (uuid), video_layout (object), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

Delete a room composition.

Synchronously delete a room composition.

DELETE /room_compositions/{room_composition_id}

go
	err := client.RoomCompositions.Delete(context.Background(), "5219b3af-87c6-4c08-9b58-5a533d893e21")
	if err != nil {
		log.Fatal(err)
	}

View a list of room participants.

GET /room_participants

go
	page, err := client.RoomParticipants.List(context.Background(), telnyx.RoomParticipantListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: context (string), id (uuid), joined_at (date-time), left_at (date-time), record_type (string), session_id (uuid), updated_at (date-time)

View a room participant.

GET /room_participants/{room_participant_id}

go
	roomParticipant, err := client.RoomParticipants.Get(context.Background(), "0ccc7b54-4df3-4bca-a65a-3da1ecc777f0")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", roomParticipant.Data)

Returns: context (string), id (uuid), joined_at (date-time), left_at (date-time), record_type (string), session_id (uuid), updated_at (date-time)

View a list of room recordings.

GET /room_recordings

go
	page, err := client.RoomRecordings.List(context.Background(), telnyx.RoomRecordingListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: codec (string), completed_at (date-time), created_at (date-time), download_url (string), duration_secs (integer), ended_at (date-time), id (uuid), participant_id (uuid), record_type (string), room_id (uuid), session_id (uuid), size_mb (float), started_at (date-time), status (enum: completed, processing), type (enum: audio, video), updated_at (date-time)

Delete several room recordings in a bulk.

DELETE /room_recordings

go
	response, err := client.RoomRecordings.DeleteBulk(context.Background(), telnyx.RoomRecordingDeleteBulkParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: room_recordings (integer)

View a room recording.

GET /room_recordings/{room_recording_id}

go
	roomRecording, err := client.RoomRecordings.Get(context.Background(), "0ccc7b54-4df3-4bca-a65a-3da1ecc777f0")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", roomRecording.Data)

Returns: codec (string), completed_at (date-time), created_at (date-time), download_url (string), duration_secs (integer), ended_at (date-time), id (uuid), participant_id (uuid), record_type (string), room_id (uuid), session_id (uuid), size_mb (float), started_at (date-time), status (enum: completed, processing), type (enum: audio, video), updated_at (date-time)

Delete a room recording.

Synchronously delete a Room Recording.

DELETE /room_recordings/{room_recording_id}

go
	err := client.RoomRecordings.Delete(context.Background(), "0ccc7b54-4df3-4bca-a65a-3da1ecc777f0")
	if err != nil {
		log.Fatal(err)
	}

View a list of room sessions.

GET /room_sessions

go
	page, err := client.Rooms.Sessions.List0(context.Background(), telnyx.RoomSessionList0Params{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active (boolean), created_at (date-time), ended_at (date-time), id (uuid), participants (arrayobject]), record_type (string), room_id (uuid), updated_at (date-time)

View a room session.

GET /room_sessions/{room_session_id}

go
	session, err := client.Rooms.Sessions.Get(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomSessionGetParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", session.Data)

Returns: active (boolean), created_at (date-time), ended_at (date-time), id (uuid), participants (arrayobject]), record_type (string), room_id (uuid), updated_at (date-time)

End a room session.

Note: this will also kick all participants currently present in the room

POST /room_sessions/{room_session_id}/actions/end

go
	response, err := client.Rooms.Sessions.Actions.End(context.Background(), "0ccc7b54-4df3-4bca-a65a-3da1ecc777f0")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: result (string)

Kick participants from a room session.

POST /room_sessions/{room_session_id}/actions/kick

Optional: exclude (arraystring]), participants (object)

go
	response, err := client.Rooms.Sessions.Actions.Kick(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomSessionActionKickParams{
			ActionsParticipantsRequest: telnyx.ActionsParticipantsRequestParam{},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: result (string)

Mute participants in room session.

POST /room_sessions/{room_session_id}/actions/mute

Optional: exclude (arraystring]), participants (object)

go
	response, err := client.Rooms.Sessions.Actions.Mute(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomSessionActionMuteParams{
			ActionsParticipantsRequest: telnyx.ActionsParticipantsRequestParam{},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: result (string)

Unmute participants in room session.

POST /room_sessions/{room_session_id}/actions/unmute

Optional: exclude (arraystring]), participants (object)

go
	response, err := client.Rooms.Sessions.Actions.Unmute(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomSessionActionUnmuteParams{
			ActionsParticipantsRequest: telnyx.ActionsParticipantsRequestParam{},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: result (string)

View a list of room participants.

GET /room_sessions/{room_session_id}/participants

go
	page, err := client.Rooms.Sessions.GetParticipants(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomSessionGetParticipantsParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: context (string), id (uuid), joined_at (date-time), left_at (date-time), record_type (string), session_id (uuid), updated_at (date-time)

View a list of rooms.

GET /rooms

go
	page, err := client.Rooms.List(context.Background(), telnyx.RoomListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active_session_id (uuid), created_at (date-time), enable_recording (boolean), id (uuid), max_participants (integer), record_type (string), sessions (arrayobject]), unique_name (string), updated_at (date-time), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

Create a room.

Synchronously create a Room.

POST /rooms

Optional: enable_recording (boolean), max_participants (integer), unique_name (string), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

go
	room, err := client.Rooms.New(context.Background(), telnyx.RoomNewParams{
		UniqueName: "my-meeting-room",
		MaxParticipants: 10,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", room.Data)

Returns: active_session_id (uuid), created_at (date-time), enable_recording (boolean), id (uuid), max_participants (integer), record_type (string), sessions (arrayobject]), unique_name (string), updated_at (date-time), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

View a room.

GET /rooms/{room_id}

go
	room, err := client.Rooms.Get(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomGetParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", room.Data)

Returns: active_session_id (uuid), created_at (date-time), enable_recording (boolean), id (uuid), max_participants (integer), record_type (string), sessions (arrayobject]), unique_name (string), updated_at (date-time), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

Update a room.

Synchronously update a Room.

PATCH /rooms/{room_id}

Optional: enable_recording (boolean), max_participants (integer), unique_name (string), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

go
	room, err := client.Rooms.Update(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomUpdateParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", room.Data)

Returns: active_session_id (uuid), created_at (date-time), enable_recording (boolean), id (uuid), max_participants (integer), record_type (string), sessions (arrayobject]), unique_name (string), updated_at (date-time), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer)

Delete a room.

Synchronously delete a Room. Participants from that room will be kicked out, they won't be able to join that room anymore, and you won't be charged anymore for that room.

DELETE /rooms/{room_id}

go
	err := client.Rooms.Delete(context.Background(), "0ccc7b54-4df3-4bca-a65a-3da1ecc777f0")
	if err != nil {
		log.Fatal(err)
	}

Create Client Token to join a room.

Synchronously create an Client Token to join a Room. Client Token is necessary to join a Telnyx Room. Client Token will expire after token_ttl_secs, a Refresh Token is also provided to refresh a Client Token, the Refresh Token expires after refresh_token_ttl_secs.

POST /rooms/{room_id}/actions/generate_join_client_token

Optional: refresh_token_ttl_secs (integer), token_ttl_secs (integer)

go
	response, err := client.Rooms.Actions.GenerateJoinClientToken(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomActionGenerateJoinClientTokenParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: refresh_token (string), refresh_token_expires_at (date-time), token (string), token_expires_at (date-time)

Refresh Client Token to join a room.

Synchronously refresh an Client Token to join a Room. Client Token is necessary to join a Telnyx Room. Client Token will expire after token_ttl_secs.

POST /rooms/{room_id}/actions/refresh_client_token — Required: refresh_token

Optional: token_ttl_secs (integer)

go
	response, err := client.Rooms.Actions.RefreshClientToken(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomActionRefreshClientTokenParams{
			RefreshToken: "eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJ0ZWxueXhfdGVsZXBob255IiwiZXhwIjoxNTkwMDEwMTQzLCJpYXQiOjE1ODc1OTA5NDMsImlzcyI6InRlbG55eF90ZWxlcGhvbnkiLCJqdGkiOiJiOGM3NDgzNy1kODllLTRhNjUtOWNmMi0zNGM3YTZmYTYwYzgiLCJuYmYiOjE1ODc1OTA5NDIsInN1YiI6IjVjN2FjN2QwLWRiNjUtNGYxMS05OGUxLWVlYzBkMWQ1YzZhZSIsInRlbF90b2tlbiI6InJqX1pra1pVT1pNeFpPZk9tTHBFVUIzc2lVN3U2UmpaRmVNOXMtZ2JfeENSNTZXRktGQUppTXlGMlQ2Q0JSbWxoX1N5MGlfbGZ5VDlBSThzRWlmOE1USUlzenl6U2xfYURuRzQ4YU81MHlhSEd1UlNZYlViU1ltOVdJaVEwZz09IiwidHlwIjoiYWNjZXNzIn0.gNEwzTow5MLLPLQENytca7pUN79PmPj6FyqZWW06ZeEmesxYpwKh0xRtA0TzLh6CDYIRHrI8seofOO0YFGDhpQ",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: token (string), token_expires_at (date-time)

View a list of room sessions.

GET /rooms/{room_id}/sessions

go
	page, err := client.Rooms.Sessions.List1(
		context.Background(),
		"0ccc7b54-4df3-4bca-a65a-3da1ecc777f0",
		telnyx.RoomSessionList1Params{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active (boolean), created_at (date-time), ended_at (date-time), id (uuid), participants (arrayobject]), record_type (string), room_id (uuid), updated_at (date-time)

Want to see if team-telnyx/telnyx-video-go would activate on your phrasing? Try it before you install — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/22/2026, 14:35 UTC · 22 cases

Lift

+68%

91% vs 23%

Agent turns

0%

1.0 vs 1.0

Tokens

+210%

6,789.59 vs 2,191.05

fail → pass · 16pass → pass · 4fail → fail · 1pass → fail · 1

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 I need a Go script using the official Telnyx Go SDK to programmatically set up a new video meeting space with a unique name and max capacity of 15 people. After creating the room, it should generate a client token so a user can join. Please provide runnable Go code that includes SDK client initialization and proper error handling for status codes like rate limits or validation errors.	fail→pass	16,700	12,768	-24%	1	1	0%	3,542	8,757	+147%	0	0	—
case-02 Can you show me a Go function that uses the Telnyx Go library to mute everyone in an active video room session? I'd like the code to initialize the client from environment variables, invoke the mute action for the session ID passed in, and check for specific API errors such as 429 rate limiting.	fail→pass	13,288	6,715	-49%	1	1	0%	2,754	7,219	+162%	0	0	—
case-03 Write a Go snippet that connects to the Telnyx Video service and requests the creation of a room composition for a finished session. The code should instantiate the SDK client using an API key from environment variables, trigger the asynchronous composition, and display the status and download details from the response struct.	fail→pass	11,288	6,022	-47%	1	1	0%	2,348	7,055	+200%	0	0	—
case-04 Write a Go function using the Telnyx Go SDK to refresh an expiring client join token for a video room given a room ID and refresh token string. Output a complete function that receives the room ID and refresh token and calls the Telnyx API.	fail→pass	11,373	6,847	-40%	1	1	0%	2,403	7,285	+203%	0	0	—
case-05 Write a Go code snippet to forcibly terminate an active Telnyx video room session using its session ID and disconnect all participants.	fail→pass	11,371	4,664	-59%	1	1	0%	2,292	6,773	+196%	0	0	—
case-06 Write a Go snippet using the Telnyx SDK to kick participants out of a video room session by calling the appropriate session action endpoint.	fail→pass	8,787	28,501	+224%	1	1	0%	1,759	6,708	+281%	0	0	—
case-11 Write a Go snippet to retrieve details for a specific Telnyx room composition using its composition ID.	fail→pass	9,853	2,888	-71%	1	1	0%	2,021	6,347	+214%	0	0	—
case-07 Write a Go snippet to unmute participants in an active Telnyx video room session given a session ID string.	fail→pass	11,863	2,972	-75%	1	1	0%	2,354	6,415	+173%	0	0	—
case-08 Write a Go code snippet using the Telnyx Go SDK that fetches all participants for a specific active or past room session given its session ID.	fail→pass	10,676	4,151	-61%	1	1	0%	2,180	6,608	+203%	0	0	—
case-09 Write a Go snippet using the Telnyx Go SDK to perform a bulk deletion of room recordings.	pass→pass	11,156	2,594	-77%	1	1	0%	2,121	6,332	+199%	0	0	—
case-10 Write a Go code snippet that queries the Telnyx API to list existing video room compositions.	fail→pass	9,571	2,574	-73%	1	1	0%	2,103	6,307	+200%	0	0	—
case-12 Write a Go function to delete a Telnyx room composition given its composition ID string.	fail→pass	8,964	6,806	-24%	1	1	0%	1,814	6,616	+265%	0	0	—
case-13 Write a Go snippet to fetch a list of video room participants across sessions using the Telnyx Go SDK.	pass→pass	8,310	2,747	-67%	1	1	0%	1,655	6,380	+285%	0	0	—
case-14 Write a Go function to look up a specific Telnyx room participant by participant ID string.	fail→pass	11,340	4,304	-62%	1	1	0%	2,419	6,807	+181%	0	0	—
case-15 Write a Go snippet to list video room recordings using the Telnyx Go SDK.	fail→pass	9,453	2,466	-74%	1	1	0%	1,889	6,334	+235%	0	0	—
case-16 Write a Go snippet to retrieve a list of all configured Telnyx video rooms.	pass→pass	12,297	15,045	+22%	1	1	0%	2,570	6,261	+144%	0	0	—
case-17 Write a Go code snippet to update room settings for a Telnyx video room specified by room ID.	fail→pass	12,595	4,114	-67%	1	1	0%	2,995	6,410	+114%	0	0	—
case-18 Write a Go function to delete a Telnyx video room using its room ID.	fail→pass	8,749	3,621	-59%	1	1	0%	1,854	6,612	+257%	0	0	—
case-19 Write a Go snippet using the Telnyx Go SDK to list room sessions under a specific room ID.	fail→pass	8,448	4,565	-46%	1	1	0%	1,592	6,340	+298%	0	0	—
case-20 Write a Go function using the Telnyx Go SDK to send an outbound SMS text message from '+18005550199' to '+18005550100' with the text 'Your code is 123456'.	fail→fail	6,442	11,329	+76%	1	1	0%	1,396	7,169	+414%	0	0	—
case-21 Write a Go code snippet using the Telnyx Go SDK to initiate an outbound phone call using the Call Control API to number '+18005550100' from connection ID '12345'.	pass→fail	9,907	6,459	-35%	1	1	0%	2,026	7,175	+254%	0	0	—
case-22 Write a JavaScript code snippet using the Telnyx WebRTC browser SDK (@telnyx/webrtc) to connect a web browser client to a video room session using a client join token.	pass→pass	10,478	8,523	-19%	1	1	0%	2,116	7,461	+253%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 22 cases were attempted. The headline lift of +68 percentage points is the difference between those two pass rates over the 22 comparable cases. 1 case got worse with the skill loaded, and it is included in that figure.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 22.7%
Pass rate with the skill: 90.9%
Cases attempted: 22
Cases counted toward lift: 22
Cases that regressed: 1
Skill version measured: v1
Run completed: 8/22/2026, 14:35 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-01

Prompt

I need a Go script using the official Telnyx Go SDK to programmatically set up a new video meeting space with a unique name and max capacity of 15 people. After creating the room, it should generate a client token so a user can join. Please provide runnable Go code that includes SDK client initialization and proper error handling for status codes like rate limits or validation errors.

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signals1 of 4 complete

BenchmarkPass rate WITH skill on a verified run91

Live evalNeeds ≥20 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+212% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

Backed by 1 of 4 signals — each added signal makes the score more robust.

Verified on gemini-3.6-flash · re-tested 6 days ago

Other measured skills in the registry, with their headline benchmark lift.