String — a surface for agent work

Today's agent tooling is islands. MCP, function calling, every framework lives in its own world. Each integration is a code project; each tool has its own shape. The agent learns each one separately, and pays for the schema in every call.

String's bet is simpler. Every capability — a document, an app, a remote URL, an editable file — gets the same shape. The agent reads a markdown file the way it reads a webpage. Actions live inline. Navigation is by link. State is scoped per topic. New capability = new markdown file. No host config, no restart, same interface in any agent.

Five surfaces. One runtime.

Different domains an agent works against — the same primitives address them all.

read

documents

/open file.md

structured

apps

/act.<name>

remote

the web

/open https://…

write

editing

/edit · /write

execution

shell · API

/exec · act.cli

A real app, end to end.

Below: a weather app — the entire app — and an agent session calling it. The agent reads the same file you do.

apps/weather/string.md

---
name: weather
type: app
default: now
---

# Weather

```act.now
GET https://wttr.in/{city}?format=%l:+%c+%t
  city, -c: string (required) "City name"
```

```act.forecast
GET https://wttr.in/{city}?format=j1
  city: string (required) "City name"
  days: number (optional) "Days to forecast" = "3"
```

Agent session

$ string app:weather '/act.now --city Seoul'

<𝒞=string:app:weather>
Seoul: ☀️ +23°C
</𝒞>

$ string app:weather '/act.forecast --city Tokyo --days 5'

<𝒞=string:app:weather>
Tokyo, 5-day forecast:
  Mon: ☀️ +28°C
  Tue: 🌤 +27°C
  Wed: 🌧 +22°C
  Thu: ⛅ +25°C
  Fri: ☀️ +29°C
</𝒞>

Hand any AI agent this instruction.

It reads the skill, installs String, and starts using apps. No SDK, no protocol negotiation, no per-agent integration code.

Copy and paste into your AI agent

Read https://www.string-os.org/skill.md and follow the instructions.

Or install directly (for humans driving String themselves): npm install -g @string-os/string

Inspectable before intentional work: /open orients, /act performs explicit work, and /source reveals the underlying SFMD — so an agent or a human can review an app before running it. v0.1 installs from trusted sources only.

Why it pays off.

50–99%

fewer tokens per task

Tool descriptions live in the page, loaded only while the agent is using it. No global tool catalog padding every call.

~50%

fewer task errors

Agents read markdown all day. Familiar interface plus self-discovery (next actions appear in the response) cut wrong-tool failures.

1×

build, run anywhere

Same markdown app runs in Claude, Codex, Cursor, custom agents. Build once, deploy everywhere.

~50 lines

per app, on average

An app is a markdown file. No build step, no schema, no host process. The file is the deliverable.

Numbers from early benchmarks comparing equivalent task completion across MCP, function calling, and String. Methodology in the docs.