Don’t enforce logic in prompts. Enforce it in infrastructure.
IAMY is an external execution layer that lets users safely perform user-initiated actions from documentation platforms, dashboards, and agent interfaces. It turns natural-language intent into a deterministic execution plan, with explicit preview, confirmation, and guarded execution.
IAMY is designed as a backend execution service that works alongside LLM models.
Intent → explicit execution plan → preview → confirm → execute → logs & audit
Modern documentation lets users read about tasks, but as docs become more interactive, they increasingly enable actions to be initiated directly from the interface. In financial or otherwise irreversible environments, this creates friction and risk. This creates a "leap of trust" problem. Once actions can be proposed by an LLM inside docs, users need strong guarantees about:
- what will happen before anything runs
- explicit confirmation and responsibility
- predictable, repeatable execution
IAMY addresses this by introducing a safety-oriented execution layer that:
- Deterministic — no hidden steps or hallucinated actions
- Previewable — execution is proposed before it runs
- Guarded — nothing executes without explicit confirmation
- Auditable — structured logs and results
- Surface-agnostic — works with docs, dashboards, and agents
A natural-language description of what a user wants to do.
A deterministic, structured plan that transforms an intent into explicit, reviewable steps.
Unlike prompt-based agent skills, an IAMY Execution Plan is not guidance for the model — it is a concrete, permissioned artifact interpreted and enforced by infrastructure.
Execution plans are not free-form outputs: they are validated against predefined schemas and preventively evaluated using expert-defined rules and policies before being shown to the user.
Guardrails define what is allowed to be proposed and executed. They encode domain knowledge and safety constraints provided by experts (e.g. read-only limits, parameter bounds, allowed operations, environment restrictions).
Guardrails are enforced before execution, ensuring unsafe or out-of-scope actions are never presented for confirmation.
Before anything runs, the user sees the full execution plan in a UI and can review every step.
After explicit user confirmation, the validated plan runs via backend services or adapters.
Structured results and logs suitable for auditing, inspection, and replay.
IAMY is built on a simple premise:
intelligence can propose actions, but infrastructure must enforce execution.
For centuries, humans — already a form of general intelligence — have relied on signatures, checklists, logs, audits, and separation of duties. Not because of lack of knowledge, but because safe execution requires physical, inspectable constraints.
AI systems are no different.
Prompt-level instructions and agent “skills” can improve reasoning, but they cannot guarantee safety, determinism, or accountability once actions affect real systems—APIs, infrastructure, or financial state.
IAMY externalizes execution from the model. Instead of trusting the agent to behave correctly, IAMY enforces:
- explicit execution plans
- preview and confirmation
- permissioned actions
- deterministic execution
- logs and auditability
This is not a workaround for weak models. It is a governance layer for applying intelligence—human or artificial—safely at scale.
IAMY is
✅ A backend execution substrate
✅ Deterministic plan generation
✅ Guarded execution modes
✅ Execution adapters for external surfaces
IAMY is not
❌ A general “AI agent”
❌ A mystery execution layer with hidden steps
❌ A replacement for user intent confirmation
This project is open source and structured to explore execution semantics safely.
We are especially interested in contributions that help:
- refine execution plan schemas
- improve adapter patterns
- add UI integrations without assuming host privileges
- explore enterprise safety modes
This project is licensed under MIT. See LICENSE for details.
Execution is a different problem from reasoning. Interfaces (docs, dashboards, agents) benefit from deterministic, auditable, and confirmable execution support — but they shouldn’t own the execution logic. IAMY provides that layer so platforms can focus on experience and users can focus on outcomes.