Every platform draws a boundary around the problems it chooses to solve. FireFoundry deliberately
moves that boundary: the responsibilities that recur on every AI project—identity, knowledge,
provider policy, governance, operations—sit inside ours.
You build business capability. No cobbling together a dozen different tools. No franken-solutions.
The SDK, Console, CLI, and APIs are not separate products. They are different experiences of one
operating model—so a routing policy set in the Console is the same policy your application uses
through the SDK, and a credential an administrator rotates affects the same capability an API invokes.
Agent SDK
TypeScript-first SDK with decorators for bots, entities, workflows, and tools.
Full type safety and IDE support out of the box.
Declarative bot definitions
Entity persistence built-in
AI-assisted development ready
CLI Tools (ff-cli)
Complete command-line toolkit for development, testing, and deployment.
From local dev to production in a single command.
Local development server
One-command deployments
Environment promotion
Runtime Platform
Production-grade runtime services that handle the hard parts:
routing, persistence, context, sandboxing, and more.
Multi-provider AI routing (text & images)
Automatic failover
Kubernetes-native scaling
Industrial-grade capacity management
Management Console
Visual dashboard for everything: monitor agents, explore data,
test in playgrounds, and manage your entire platform.
Real-time monitoring
Interactive playgrounds
Visual entity graph explorer
Knowledge Infrastructure
Built-in RAG, document processing, and entity persistence.
No external vector DB or document extraction service needed.
Knowledge bases with RAG
Automatic document extraction
Persistent entity graph
Data Access Service
Semantic database proxy for AI agents. 12+ backend databases through one API with business context, access control, and governed queries.
Multi-database unified access
Semantic data dictionary
Fine-grained access control
Web Search Service
Provider-agnostic web search for AI agents. Structured queries, result normalization, and full observability across providers.
Structured query support
Provider-agnostic abstraction
Spelling correction & related searches
Functions-as-a-Service†
Where an agent's useful work goes to live. The sandbox handles ad-hoc code; when something
proves worth keeping—at the agent's discretion or an operator's—it can be promoted
to a named function that anything can call over HTTP. The library grows as your agents learn
what works, instead of the same code being regenerated on every run.
Promote sandbox code to a reusable function
Callable by agents, applications, or anything else
Reaches allow-listed platform services, such as governed data access
Runs in FireFoundry runtimes that carry the caller's identity downstream
Multiple runtime environments
Widget-as-a-Service for dashboards
Automatic scaling & resource management
Enterprise Operations
Security, environments, access control, and audit logging.
Everything IT needs to operate AI at scale.
Role-based access control
Environment management
Complete audit logging
Cloud resource discovery & Terraform export
Notification Service
Multi-channel notification delivery with provider abstraction, idempotency, and audit trails. Email and SMS today, push coming soon.
Pluggable provider architecture
Database-level idempotency
Complete send audit trail
Log Proxy Service
Structured log capture with session correlation, searchable log index, and Enterprise-tier PII redaction and encrypted storage.
Session-correlated traces
Log search and filtering
PII redaction (Enterprise)
Identity Service†
A canonical model of principals, groups, and permissions that is independent of your identity provider. Policy can finally name the people who use an application, not only the administrators who deploy it.
Principals, groups, permissions
IdP-agnostic, works with your directory
Permissions over applications and agents
MCP Gateway
One place where Model Context Protocol tools and resources are consolidated, so every application does not stand up and secure its own connections.
Centralized tool and resource registry
Shared credentials and access policy
Consistent tool surface across agents
Skills Service
Uploadable, versioned packages that extend what agents can do. Publish a capability once and let every application consume the same tested version.
Versioned skill and tool packages
Upload, publish, and roll back
Shared across applications
Virtual Workers
Managed, session-based AI code generation running inside the platform, with the same identity, telemetry, and lifecycle as everything else you operate.
Session-based generation workers
Governed like any other workload
Full telemetry and cost attribution
Browser Automation†
Persistent, credentialed browser sessions an agent can drive, for the systems that never got an API. Consumed as a capability interface, with credentials and policy handled by the environment.
Persistent session lifecycle
Credentials injected, never authored by the agent
Governed like any other capability
† In beta or active development.
We mark these rather than blur them.
Inside Our Boundary, Not Yours
The question isn't whether these problems can be solved with existing services. It's whether every
enterprise should have to solve them independently. Each item below is a decision, an integration,
and a support relationship that stops being yours.
Persistent Entity Graph
No vector database setup. Business objects persist automatically with relationships.
Full Telemetry
No OpenTelemetry configuration. Every request traced from start to finish.
Distributed Tracing
Follow requests across services. Debug production issues in minutes.
Document Extraction
No Unstructured.io integration. PDFs, docs, and more processed automatically.
Safe Code Execution
No Modal or E2B setup. Secure sandboxes with resource limits built-in.
Multi-Provider Routing
No abstraction layer to write. Route to OpenAI, Anthropic, or others seamlessly.
Automatic Failover
No retry logic to implement. Provider failures handled transparently.
Knowledge Bases
No RAG pipeline to build. Upload documents, get grounded responses.
Test Harness
No eval framework to build. Deterministic testing for non-deterministic AI.
Environment Management
No GitOps complexity. Promote from dev to staging to prod with confidence.
RBAC & Access Control
No auth system to build. Roles, permissions, and team management included.
Audit Logging
No logging infrastructure. Every action tracked for compliance.
Data Intelligence
No custom database integrations. Agents query your data through a semantic layer with built-in governance.
Image Generation
No separate image service. Generate and edit images through the same broker that handles text.
Cloud Resource Sync
No double-entry. Discover and import existing cloud resources automatically.
Agent Function Library †
No deployment pipeline to reuse what an agent built. Promote useful sandbox code to a named function and call it like any other API.
Application Lifecycle
No bespoke deployment conventions per team. An application is a managed object with its own identity, endpoints, and environments.
Model Groups & QoS Tiers
No routing logic in application code. Group deployments across providers, set a service tier, and let agents inherit the policy.
Graph Projections
No hand-rolled context assembly. Purpose-specific views over the entity graph, so agents read what a task needs instead of everything.
Declarative Bundles †
No TypeScript required for straightforward agents. Declare entities, workflows, bots, and prompts in markup and let the runtime bootstrap them.
† In beta or active development.
No More Franken-Solutions
Stop stitching together a dozen different tools that weren't designed to work together.
No more compatibility nightmares, version conflicts, or integration debugging.
With FireFoundry, everything is designed as a cohesive whole.
The SDK talks to the runtime which feeds the console which powers the CLI.
It all just works.
The Console exposes the operational surface that matters for enterprise AI—models, agents, data,
knowledge, and environments—so administrators aren't moving between provider portals and
project-specific tools to answer one question.
Real-time dashboard with key metrics and status
Visual entity graph for exploring persistent data
Full telemetry with request tracing
Interactive playground for testing agents
Multi-environment management and promotion
Role-based access control and permissions
Evaluate Anyone, Including Us
Five questions worth asking any candidate
Consolidated AI development surfaces are easily mistaken for complete operating environments. These
five questions separate the two quickly, because a prototyping platform's honest answers are always
the same: cloud primitives, project topology, or code you write yourself. Ask them of us too.
1
Who are the application's end users, and what may each of them do?
Canonical principals, groups, and permissions — independent of your identity provider, and expressed over the people who actually use the application, not just the administrators who deploy it. †
2
What is the application, beyond an endpoint?
A managed lifecycle object with its own identity, endpoints, and environments — something the enterprise can own, promote, and retire, rather than a URL in front of some code.
3
Who owns the knowledge, and who approved it?
Knowledge bases are stewarded enterprise assets with owners, ingestion pipelines, and approvals — not a retrieval index a developer configures and nobody governs.
4
Where does business policy live and execute?
On the request path. Access control, redaction, and human approval run inline and land in the audit log, so policy is enforced rather than documented.
5
Who is accountable when the integrated system fails?
One boundary, one support relationship, and forward-deployed engineers who stay after go-live. Not a matrix of vendors pointing at each other.
† In beta or active development. We mark
these rather than blur them — a forward-looking roadmap is only useful if you can tell it apart
from what ships today.
One Control Plane for the Whole Lifecycle
Every capability in FireFoundry serves one of four stages. The same governed surface carries an
application from a first useful result to a portfolio someone is accountable for.
Build
Get to a useful first result
Typed entities, bots, and workflows
Deterministic local testing with model mocking
Declarative XML bundles †
AI-assisted development on real code
Govern
Policy on the request path, from the start
Canonical end-user identity †
Access control, policy and PII redaction
Human approval in the request flow
Audit logging across data and administration
Scale
Decide once, inherit everywhere
Model groups, QoS tiers, cross-provider failover
Centralized credential lifecycle
Configuration over code
Environment promotion: dev to production
Monitor
Signals connected to an owner
Distributed tracing of full request trees
Attribution by application, agent, and stage
AI-assisted incident diagnostics
Centralized logs with redaction
† In beta or active development.
Ready to Stop Assembling Your Own?
Build business capability. We own the environment around it.
