s-m-r-t
Open the s-m-r-t source on GitHub Switch to dark color scheme
← Capabilities

Framework approach

Build an application agents can understand

s-m-r-t describes the application at several layers. An agent can inspect declared domain logic, understand visible controls, and discover permitted operations. An exposed runtime bridge also lets the agent observe the active environment.

Agent understanding
Domain manifestOptional runtime bridgeForm controlsMCP tools
Explicit registries describe the application from source through the active interface.

One application, four semantic views

Each registry answers a different question. Together they give people and agents a consistent map from what the product means to what this particular environment can do.

  • The domain manifest describes objects, fields, relationships, policies, and declared interfaces.
  • When exposed, the runtime-environment registry describes which modules and capabilities are actually available in the active process.
  • The control registry describes the visible form controls, their meaning, constraints, sensitivity, and state.
  • MCP and WebMCP schemas describe the operations an agent may request at the current boundary.

Compare what is declared with what is running

The runtime-environment registry is designed as a bounded bridge for development tooling. When a development MCP connection exposes that registry, an agent can compare workspace knowledge with the active process. The agent does not assume that a build artifact and its process agree.

  • Missing or stale registrations become diagnosable facts instead of mysterious runtime failures.
  • Environment-specific modules and adapters can be discovered without hard-coding one deployment shape.
  • The registry exposes capability metadata, not application records, credentials, principals, or tenant data.
Development MCP and its runtime boundary →

Use the same pattern in the visible interface

Agent-assisted forms make controls legible in the same way. A stable form and control identity replaces DOM position or visible wording, while descriptions, options, validation, and sensitivity travel with the control.

  • Chat, voice, tutorials, and tests can share one control description.
  • Highlight, explain, and validate commands can help without changing a value.
  • Staged changes keep the proposed value separate until a confirmed apply command.
Try the agent-assisted form pattern →

Awareness is not authority

Describing an environment or control does not grant permission to operate it. Development metadata remains separate from live data operations, and runtime calls still resolve through the application principal, tenant scope, field policy, and explicit confirmation rules.

  • The development MCP understands code and, when connected, bounded capability metadata; generated local MCP, hosted application MCP, and WebMCP perform permitted data operations.
  • Secret values stay out of control descriptions and generated outputs.
  • An application can expose a narrow tool set even when its model supports more operations internally.

Why explicit registries beat reverse-engineering

A semantic contract is stable across layout changes, deployment shapes, and agent providers. The same metadata also improves documentation, accessibility, validation, testing, and generated interfaces, so making the application legible does not create a separate agent-only implementation.

  • Less duplicated integration code and fewer human/agent interface drift bugs.
  • More reliable automation than filesystem, DOM, or screenshot guessing.
  • One inspectable boundary for builders, operators, tests, chat, and voice experiences.
  • Security hardening flows through the shared model and registries instead of being recreated per adapter.