convez.ai
MCP ServerIntegração & APIsAvançado
string-os

String — Framework de Apps Agnóstico para Agentes IA

string-os/string

Uma superfície única para apps, web e docs — agnóstica a agentes

Ver no GitHub
BomPluginScore · de 0 a 100

String é um framework que unifica aplicações, páginas web e documentos Markdown em uma superfície única agnóstica para agentes IA. Define um protocolo padrão (SFMD) que permite ao agente operar aplicações, documentos locais, páginas web, APIs e sessões shell através de comandos consistentes (/open, /act, /info), sem necessidade de aprender múltiplos esquemas de API.

Instalação

$npx convez-ai string-os/string

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
78
Forks
5
Acompanhando
0
Saúde
87%
Último commit
há 5 dias
Versão
v0.1.15
Issues abertas
5
Contribuidores
4

Casos de uso

  • Construir aplicações que agentes IA podem navegar e controlar nativamente
  • Converter páginas web em interfaces estruturadas legíveis por agentes
  • Unificar acesso a apps locais, APIs, arquivos e shell em um único protocolo
  • Criar fluxos de trabalho com auto-descoberta de ações disponíveis

Veredito

String é uma proposta ousada e bem-pensada para interoperabilidade entre agentes e sistemas. O design minimalista (apenas 3 comandos core) é um trunfo, mas a maturidade do ecossistema de apps ainda está em construção. Recomendado para builders que querem dar aos agentes uma camada coerente de abstração.

README

A tradução para o português deste README ainda está na fila.

String

An app framework and browser for AI agents.

String unifies apps, the web, and Markdown documents into one agent-native surface. A website can expose navigation and actions in Markdown, so an agent can use it like an app. Ordinary web pages still open as clean Markdown. Installed apps, local documents, web pages, files, APIs, and shell sessions all use the same commands.

The core loop is intentionally small:

/open  read a document, app, web page, file, or shell session
/act   call an available action
/info  understand where you are

String can run as a CLI, a daemon, or one MCP tool named string. The agent learns one surface and uses it everywhere.

Available String apps are maintained at github.com/string-os/apps.


Why

Most agent integrations grow the agent's context: another tool schema, another API manual, another set of examples. String moves that knowledge into the app or page itself.

An agent opens a page, sees what actions are available, calls one, and follows the next hint. The page may be a local Markdown file, an installed app, an agent-native website, or a normal website rendered as Markdown. The interaction is the same.

What changes:

  • Apps and web share one model. A String app and an agent-native web page expose the same surface: Markdown content, navigation, actions, state, and hints.
  • One browser for agent work. /open, /act, /info, and topics work the same for documents, apps, web pages, files, APIs, and shell sessions.
  • Self-discovery. Actions expose schemas with /act --help; responses carry next: hints; errors carry recovery hints.
  • Local command boundary. Web-hosted SFMD can call web APIs, but local shell commands run only from local files or locally installed apps.
  • Agent event inbox. Local webhooks can deliver text events to an agent, which reads and acknowledges them through the same CLI/MCP surface, or receives as a Claude Code channel notification.
  • Credentials stay scoped. App secrets are set inside app topics with /set $VAR = "...", not pasted into the agent's prompt.
  • Portable by default. A String surface is Markdown. It can live in a file, an installed package, a GitHub repo, or on the web.

String calls this format SFMD: String Flavored Markdown. It is normal Markdown plus lightweight navigation, action blocks, and response conventions.


One Surface

No SDK. No endpoint memorized. The surface tells the agent what it can do.

Open a web page as Markdown:

string main '/open https://docs.string-os.org/runtime/mcp'

Open an installed app and follow its actions:

string app:moltbook '/open'
# [actions] home, feed, read, comment, post, search
# next: /act.feed · /act.search "..."

string app:moltbook '/act.feed'
# Feed: @post-1 through @post-20
# next: /act.read @post-N

string app:moltbook '/act.read @post-3'
# ...post body...
# next: /act.comment @post "..."

The same interaction over MCP is one tool call:

{ "topic": "app:moltbook", "cmd": "/act.read @post-3" }

Install

Claude Code Plugin

/plugin marketplace add string-os/string
/plugin install string@string-os

This installs the String MCP tool and a short skill for using it. The tool is registered as server string and exposes one tool named string.

For multiple local agents or workspace-specific homes, see Agent Identity.

To receive local String webhook events directly inside Claude Code, launch Claude Code with the String plugin channel and select the local agent id:

string agent add leo --home /home/ubuntu/crew/leo

STRING_AGENT_ID=leo \
claude \
  --dangerously-load-development-channels plugin:string@string-os

That keeps the plugin-provided string MCP tool available and also pushes local events for the selected String agent into the Claude Code session. The official Discord channel can be loaded at the same time with --channels plugin:discord@claude-plugins-official.

Codex Plugin

codex plugin marketplace add string-os/string
codex plugin add string@string-os

CLI

npm install -g @string-os/string
string --help

The daemon starts automatically on first use. Default port: 3923.


Basic CLI

string main '/open ./README.md'
string main '/open https://docs.string-os.org/runtime/mcp'
string app:weather '/act.now Seoul'
string bash:dev 'pwd && ls'

Topics scope state:

TopicUse
main, notes, researchfree-form document/web sessions
app:<name>installed app session
app:<name>:<config>app session with config-scoped env
bash:<name>persistent shell session
app, tool, bash, event, system, agenthub topics for runtime views and management

Hub topics are reserved. Open them to inspect runtime state, or send management commands through their hub:

string app            # installed apps + active app sessions
string event          # event inbox + local webhook URL
string system status
string agent list

Every response is wrapped so an agent can separate String output from shell noise:

<𝒞=string:main>
...
</𝒞>

MCP

String serves MCP directly. No separate MCP package is needed.

{
  "mcpServers": {
    "string": {
      "command": "npx",
      "args": ["-y", "@string-os/string", "--mcp"]
    }
  }
}

The MCP tool takes:

{ "topic": "main", "cmd": "/info" }

For local webhook event delivery into Claude Code Remote Control channels, see Events and Local Webhooks.

Use /help, /info, and /act --help to discover what is available.


Surfaces, Not SDKs

A String surface can be:

  • a local Markdown document
  • an installed app
  • a web page that exposes Markdown navigation and actions
  • an ordinary web page rendered as Markdown
  • a shell session or file workspace

The agent uses the same commands either way. When a surface includes SFMD action blocks, it becomes executable.

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

# Weather

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

Install that file as an app and call it:

string main '/install --app ./weather.md'
string app:weather '/act.now Seoul'

The Markdown is the interface. The runtime handles discovery, argument parsing, execution, output framing, state, and credentials.


Docs

Packages

  • @string-os/string — CLI, daemon, MCP server, runtime
  • @string-os/client — HTTP/SSE client for stringd
  • @string-os/core — SFMD parser
  • @string-os/compiler — SFMD validator/compiler

License

MIT

Ver o original no GitHub

Bom para

Relacionados