Your AI agent reads 200 fields. It only needs 8.

# Python
from plinth import Plynf

client = Plynf(
    workspace_url="http://localhost:7421",
    gateway_url="http://localhost:7422",
    api_key="local-dev",
)

ws = client.workspace("my-research")
ws.kv.set("topic", "renewable energy")

# Token-efficient: stores in workspace, doesn't bloat prompt history
sources = client.tools.invoke("web.search", {"query": "renewable energy"})
for src in sources["results"]:
    content = client.tools.invoke("web.fetch", {"url": src["url"]})  # cached
    ws.files.write(f"sources/{slug(src['url'])}.txt", content)

ws.snapshot("sources-collected")

// TypeScript
import { Plynf } from "@plinth/sdk";

const client = new Plynf({
  workspaceUrl: "http://localhost:7421",
  gatewayUrl: "http://localhost:7422",
  apiKey: "local-dev",
});

const ws = client.workspace("my-research");
await ws.kv.set("topic", "renewable energy");

// Token-efficient: stores in workspace, doesn't bloat prompt history
const sources = await client.tools.invoke("web.search", {
  query: "renewable energy",
});
for (const src of sources.results) {
  const content = await client.tools.invoke("web.fetch", { url: src.url }); // cached
  await ws.files.write(`sources/${slug(src.url)}.txt`, content);
}

await ws.snapshot("sources-collected");

// Go
package main

import (
    "context"
    "github.com/plinth/sdk-go/plinth"
)

func main() {
    ctx := context.Background()
    client, _ := plinth.New(plinth.Config{
        WorkspaceURL: "http://localhost:7421",
        GatewayURL:   "http://localhost:7422",
        APIKey:       "local-dev",
    })

    ws := client.Workspace("my-research")
    _ = ws.KV.Set(ctx, "topic", "renewable energy")

    // Token-efficient: stores in workspace, doesn't bloat prompt history
    sources, _ := client.Tools.Invoke(ctx, "web.search", map[string]any{
        "query": "renewable energy",
    })
    for _, src := range sources["results"].([]any) {
        content, _ := client.Tools.Invoke(ctx, "web.fetch", map[string]any{
            "url": src.(map[string]any)["url"],
        }) // cached
        _ = ws.Files.Write(ctx, "sources/"+slug(src)+".txt", content)
    }

    _ = ws.Snapshot(ctx, "sources-collected")
}

// Swift
import Plynf

let client = Plynf(
    workspaceURL: URL(string: "http://localhost:7421")!,
    gatewayURL:   URL(string: "http://localhost:7422")!,
    apiKey: "local-dev"
)

let ws = client.workspace("my-research")
try await ws.kv.set("topic", value: "renewable energy")

// Token-efficient: stores in workspace, doesn't bloat prompt history
let sources = try await client.tools.invoke(
    "web.search",
    args: ["query": "renewable energy"]
)
for src in sources.results {
    let content = try await client.tools.invoke(
        "web.fetch",
        args: ["url": src.url]
    ) // cached
    try await ws.files.write("sources/\(slug(src.url)).txt", content)
}

try await ws.snapshot("sources-collected")

// Kotlin
import dev.plinth.Plynf

suspend fun main() {
    val client = Plynf(
        workspaceUrl = "http://localhost:7421",
        gatewayUrl   = "http://localhost:7422",
        apiKey       = "local-dev",
    )

    val ws = client.workspace("my-research")
    ws.kv.set("topic", "renewable energy")

    // Token-efficient: stores in workspace, doesn't bloat prompt history
    val sources = client.tools.invoke(
        "web.search",
        mapOf("query" to "renewable energy")
    )
    for (src in sources["results"] as List<Map<String, Any>>) {
        val content = client.tools.invoke(
            "web.fetch",
            mapOf("url" to src["url"])
        ) // cached
        ws.files.write("sources/${slug(src["url"] as String)}.txt", content)
    }

    ws.snapshot("sources-collected")
}