ai agent & mcp Build, test, and release backends with AI.
Fluxify features a ground-up rewritten autonomous AI agent runner and a comprehensive Model Context Protocol (MCP) server. Work interactively in the editor chat with visual canvas diffs, or let Claude Code, Cursor, and Windsurf drive your backend through 65+ native tools.
Read the docs-
01 Client & Protocol Layer
Connect via the in-editor Chat UI with live streaming, or connect external coding agents (Claude Code, Cursor, Windsurf) through the built-in MCP server with Personal Access Tokens or OAuth 2.0.
- Chat UI
- MCP Protocol
- OAuth 2.0
- PAT Auth
- SSE Streaming
-
02 Autonomous Agent Runner
A single-loop runner that reasons, selects tools, and executes actions. Choose between Manual (approval per action), Auto (guarded autonomy), or Plan (structured execution proposal).
- Manual Mode
- Auto Mode
- Plan Mode
- Repeat Guards
- Token Ceilings
-
03 Context & Cache Optimization
Importance-weighted tool trimming and smart context compaction preserve token budgets across long multi-turn sessions. Prefix-preserving batching maximizes Anthropic/OpenAI prompt cache hits.
- Smart Compaction
- Prompt Caching
- Trim by Importance
- Budget Line
-
04 Visual Canvas Diffs & Review
Changes to routes, workflows, and custom blocks produce visual color-coded node diffs with block settings preview. Review, bulk-approve, or reject with direct feedback before applying.
- edit_canvas
- Visual Diffs
- Bulk Approvals
- Dry Run Checks
- Rejection Reasons
-
05 65+ MCP Platform Tools
Complete programmatic control over Fluxify: inspect block schemas, execute routes, run and validate test suites, experiment in private sandboxes, snapshot versions, and read docs.
- Canvas Tools
- Resource CRUD
- Test Suites
- Sandboxes
- Versions
- Debug Errors
execution modes
Three ways to collaborate.
Switch between granular step-by-step approvals, guarded autonomy, or high-level design planning depending on task sensitivity.
visual reviews
Canvas diffs right in the chat.
When the agent alters a route, workflow, or custom block, it generates a visual canvas diff before writing changes. See added blocks in green, removed edges in red, and modified settings side-by-side.
- Dry-run validation: The canvas compiler checks block schemas, input types, and cycle detection before displaying the preview.
- Bulk tool approvals: Review complex multi-step canvas transformations in one collective approval dialog.
- Rejection with feedback: Reject a proposed edit with a specific comment; the agent uses your feedback to adjust its canvas plan.
guided autonomy
Plan before executing. Track with live todos.
For multi-step architecture changes, the agent suggests a structured Plan Card. Once approved, a real-time Todo list popover tracks execution progress across turns.
Plan card suggestions
The agent proposes ordered milestones before modifying your working copy. Review the strategy, adjust steps, or approve with one click.
Live todo popover
A dedicated tasks popover updates in real time as the agent writes routes, attaches test suites, and verifies execution with loopback tests.
Context @mentions
Reference @routes, @tables, @custom-blocks, or @knowledge-base in chat to supply instant schema context.
model context protocol
65+ native tools for any AI client.
Fluxify exposes an official, full-featured MCP server over SSE and HTTP. Connect Cursor, Claude Code, Windsurf, or custom agent sidecars with one-click token setup.
Canvas & Flow Building
Inspect wiring, validate handle connections, apply surgical canvas diffs, or run ephemeral blocks on dev data without creating a route.
get_canvas
edit_canvas
copy_blocks
run_blocks
get_block_schemas
Resource Management
Create and update every resource. Tools validate schemas, path availability, and dependency relationships.
save_route
save_workflow
save_trigger
save_custom_block
save_middleware
save_integration
save_app_config
Testing & Debugging
Send test requests over loopback, run assertions, and capture detailed debug error headers to fix issues autonomously.
call_route
run_test_suite
validate_test_suite
save_test_suite
get_test_runs
External MCP & Domain RAG
Query company domain docs, retrieve architecture standards, and execute tools on external OAuth-connected MCP servers.
search_knowledge_base
read_knowledge_page
mcp_list_tools
mcp_call_tool
Private Sandboxes
Spin up isolated scratch canvases on development data to prototype ideas or inspect DB tables with DB Native.
create_sandbox
get_sandbox
call_sandbox
run_sandbox
delete_sandbox
Releases & Versioning
Snapshot working copies into immutable versions, restore past states, and promote to production through automated quality gates.
commit_version
checkout_version
list_versions
promote_version
rollback_version
Observability & Docs
Replay past executions with block-level inputs and outputs, read compile logs, and search docs at heading-level granularity.
list_recordings
get_recording
get_system_logs
search_docs
read_doc
Plug into your IDE or terminal
Generate a Personal Access Token (PAT) under Account → Access Tokens or authenticate via standard OAuth 2.0 with browser consent. Paste the config into your tool of choice.
{
"mcpServers": {
"fluxify": {
"url": "https://fluxify.example.com/_/admin/mcp",
"headers": {
"Authorization": "Bearer flx_pat_7a8b9c0d1e2f..."
}
}
}
}external integrations & RAG
External MCP servers with OAuth, and domain RAG.
Connect external MCP servers to equip the agent with outside tools, and ground its answers in your company's own knowledge base.
External MCP Client & OAuth 2.0
Fluxify connects to external MCP servers via SSE and stdio. Full OAuth 2.0 authorization code flows with automated token refreshes allow the agent to run tools from third-party services securely.
- One-click OAuth connect with browser approval
- Shared project account with automated refresh tokens
- Dynamic external tool discovery for agent runs
Project Custom Knowledge Base
Teach the agent your team's domain rules, database schemas, and conventions. Manage markdown documentation directly in project settings with instant hybrid vector search.
- In-portal markdown editor for architecture notes
- Hybrid RAG retrieval over project documentation
- Zero hallucinations on internal endpoints and schemas
context & debug loop
Smart compaction & autonomous fixing.
Long backend tasks generate large schemas and test runs. Smart compaction trims low-value tokens while keeping instruction prefixes stable to maximize prompt caching.
// apps/ai-gateway/src/agent/compact.ts
// 1. Prefix-preserving compaction keeps Anthropic / OpenAI prompt cache warm
// 2. Trims old tool results by importance:
// - High: user instructions, error messages, latest canvas diffs
// - Medium: summaries of completed tool executions
// - Low: repetitive schema lookups and raw test payloads
// 3. Replaces lengthy canvas blocks with concise structural summaries
// 4. Maintains strict token budget ceilings with automatic continue triggers01 · Test execution failure
The agent calls call_route; route throws "Cannot read properties of undefined (reading 'email')".
02 · Header debug diagnosis
The runner captures the 4 KB debug error header identifying block db_lookup_user.
03 · Autonomous patch & re-verification
Agent adds a Not Found branch socket, validates the canvas with edit_canvas, and re-tests until green.
model routing
Bring your own model keys.
Connect your preferred AI provider in Project Settings. API keys are stored encrypted; the agent runner manages model formats, retries, and rate limits.
Anthropic
Claude 3.7 Sonnet, Claude 3.5 Sonnet / Haiku · prompt caching
OpenAI
GPT-4o, GPT-4o-mini, o1 / o3-mini · structured output & tool calling
Google Gemini
Gemini 2.5 Pro / Flash · native structured output
Mistral
Mistral Large / Codestral · JSON mode fallback
OpenAI-compatible
Ollama, vLLM, DeepSeek or any server with an OpenAI-compatible endpoint