Agents & orchestrators

Built for agents that need
real trust signals

FunctionFly exposes functions with clear manifests, verification metadata, and execution-backed trust scores—so policies can distinguish "callable" from "appropriate to call."

Discovery, trust, and execution

Tools ship with structured configuration, schemas, and attestations—so agents can match intent to capability without guessing.

Discovery & manifests

Tools ship with structured configuration and I/O schemas so agents and orchestrators can match intent to capability without guessing.

  • →Stable tool identity and versioning
  • →Schema-first inputs and outputs
  • →Policy hooks for capability and constraints

Trust API

Query attestations, scores, and verification-friendly metadata to enforce budgets and trust tiers at selection time and runtime.

  • →Batch-friendly score lookups
  • →Verification and reporting flows
  • →Usage-based metering for partner workloads

Human + platform verification

Verification levels stack from format checks through platform-signed tooling. See the full model and what agents actually consume at runtime.

  • →Multi-level verification ladder
  • →Signing, attestations, and revocation posture
  • →Execution-backed score components

From discovery to a safe tool call

Orchestrators can treat FunctionFly as the source of truth for "what this tool is" and "whether it is allowed right now."

1
Discover
List candidate tools from the registry with manifests and declared capabilities.
2
Score
Call the Trust API for trust tier, verification level, and components that match your policy.
3
Decide
Apply budgets, tiers, and org rules before the model is allowed to bind a tool.
4
Execute
Run the function with observability; scores update from real execution history.

Agent execution

Dedicated agent plans cover tool-call volume, concurrency, and guardrails when your agents outgrow ad-hoc usage. Align spend with how often tools actually run.

  • ✓ Tool-call quotas and burst limits
  • ✓ Per-agent cost visibility
  • ✓ Enterprise options for custom caps

Stateful tools with State Fabric

Long-running or multi-step agents often need durable state, not just stateless HTTP calls. State Fabric adds structured state, snapshots, and replay-oriented workflows on top of your functions.

  • ✓ Optional add-ons for cache, security, and AI memory
  • ✓ Tiers from sandbox through enterprise
  • ✓ Billed alongside your workspace plan

Trust API at a glance

Authenticate with a partner API key, then read scores or drive verification. Full request and response shapes live in the docs.

GET
/v1/trust/score/:function_id

Current trust score, tier, verification level, and component breakdown.

POST
/v1/trust/batch

Batch score lookup for tool shortlists and ranking.

GET
/v1/trust/history/:function_id

Historical windows for drift detection and policy audits.

POST
/v1/trust/verify

Submit a verification request (scoped key required).

FAQ

Do agents need FunctionFly accounts?
Your product integrates with FunctionFly using API keys and workspace configuration. End-user agents typically talk to your backend, which enforces policy and calls FunctionFly as needed.
How does this relate to the zero-knowledge vault?
Tools can use secrets without the platform ever seeing plaintext: encryption stays client-side. That pairs well with agent toolchains that must not leak credentials into prompts or logs.
Where do I start?
Create your workspace to publish or connect functions, then wire the Trust API into your tool-selection path. Use Trust layer for the verification model and Pricing for execution and State Fabric.

Ship agents that choose tools with evidence

Connect manifests, trust scores, and execution-backed signals in one place—then scale with agent plans and State Fabric when workloads grow.

live: Trust API live