Write the logic.
Not the plumbing.
Use real Python and React. Work with PostgreSQL, DuckDB, and PySpark. Vortexify provides the resource model, data access, and managed execution around the code.
# Transform body / permitted project inputs
def prepare_readiness(order_lines):
result = order_lines.copy()
result["shortage"] = (
result["required_qty"]
- result["available_qty"]
).clip(lower=0)
return resultIllustrative transform body. The SDK supplies resource definitions, inputs, and compute configuration.
One codebase.
More than one way to build.
Project context records what you want to build; the knowledge base preserves what the business means. Agents can work with both alongside your code. Choose the development workflow that suits your team.
Illustrative project document
Work through the project in Vortexify.
Work with project context, inspect connected resources, and coordinate changes across the application from the Vortexify workspace.
- 01Read the requirements and business rules
- 02Inspect connected data and existing resources
- 03Plan, implement, test, and iterate
Bring your coding workflow.
Use Codex or Claude Code with the Vortexify CLI, SDKs, and project context. The platform remains the execution environment.
- 01Work with the project in your editor
- 02Use the same context and resource definitions
- 03Preview, test, and deploy the changes
Keep the code in your hands.
Develop directly with Python, React, and the SDKs. Edit business logic, tests, and interfaces without being limited to generated components.
- 01Choose your project structure
- 02Inspect and edit the implementation
- 03Use managed resources for execution
Choose the technology
that fits the job.
The point is not to make every workload look the same. It is to give each workload a place to run, with the right data access and connections to the rest of the application.
# Transform body / permitted project inputs
def prepare_readiness(order_lines):
result = order_lines.copy()
result["shortage"] = (
result["required_qty"]
- result["available_qty"]
).clip(lower=0)
return resultRepresentative logic, not a complete SDK declaration. See the documentation for configuration and inputs.
Familiar Python data work.
Use DataFrames for preparation, business logic, and analysis. Let the platform supply the permitted inputs and execute the resource.
# Query body / registered project table
def prepare_readiness(conn):
return conn.execute("""
SELECT *, GREATEST(
required_qty - available_qty, 0
) AS shortage
FROM order_lines
""").df()Representative logic, not a complete SDK declaration. See the documentation for configuration and inputs.
SQL where it makes sense.
Write analytical queries with a DuckDB connection rather than provisioning a separate query environment for every application.
from pyspark.sql import functions as F
# Distributed transformation body
def prepare_readiness(order_lines):
return order_lines.withColumn(
"shortage", F.greatest(
F.col("required_qty")
- F.col("available_qty"),
F.lit(0)
)
)Representative logic, not a complete SDK declaration. See the documentation for configuration and inputs.
Distributed processing, real code.
Keep the transformation in PySpark when the workload needs distributed execution. Configure the driver and executor resources through the platform.
Write the operation.
Keep the controls around it.
The code defines the business behavior. Vortexify provides the connected execution environment and the boundaries around that behavior.
Application request
The operator is signed in as themselves.
Permission check
Authorize the action against its resources.
Isolated execution
Run the logic with permitted data and connections.
Result and activity record
Return the outcome; retain the applicable audit event.
Your code decides
what the work means.
Does this order have every part? Has its inspection passed? What happens when it is released?
An iframe separates a browser preview. Backend permissions and workload isolation provide separate controls for data and execution.
How the security boundaries fit togetherA documented starting point.
Not a hard integration limit.
Use public references for 150+ common systems. For a different vendor or a custom API, supply its technical documentation — including large PDFs — and have the agent implement the connector and sync logic.
Commonly used systems
Public documentation and implementation references.
SaaS · APIs · Files
Your vendor documentation
API specifications, technical guides, and large PDF manuals.
Endpoints · Pagination
# Conceptual agent configuration
Name supply_risk_analyst
Context business rules + prepared tables
Tools readiness_api, compare_allocations
Capabilities SQL analysis, code, charts
Task review tomorrow’s shortages
Schedule every weekday morning
Output findings + proposed actions
Embedded in an app, or delegated a task.Give the agent
a context and a contract.
Connect a specialized agent to relevant data, project knowledge, and the APIs it is allowed to use. Enable analysis capabilities and surface its work through your application or a scheduled task.
Go deeper in the documentation.
Start a project
CLI setup, project configuration, and the development workflow.
Open getting startedDefine your resources
Python and React SDKs, resource inputs, application logic, and deployment.
Explore the documentationConnect your systems
Authentication, source discovery, syncs, tables, and operational data access.
Read integration guidesLinks open the existing Vortexify documentation. The new SDK examples and information architecture should be synchronized with the product release before publication.
Keep your code.
Gain a working environment.
Use your preferred coding agents, the Vortexify CLI and SDKs, or a direct development workflow. Build on the same connected platform.