Features & Deploy

An action in Skene is a growth automation rule: when something happens in your database, take an action. Features are compiled into state machines and deployed as Postgres triggers.

In the workspace sidebar, configured loops are listed under Actions (/workspace/<slug>/agent-actions) when your Supabase connection is read-write.

Three ways to create features

1. Premade templates

The fastest way to get started. Open Actions and create from a template library:

Each template includes a pre-configured trigger, data requirements, and action. During deploy, Skene matches the template to your schema and asks you to confirm the table mapping.

2. Skene Agent

Describe what you want in natural language. The Agent is available from:

• The Agent page (dedicated chat interface)
• Context panels where loops are edited
• The Overview workspace home

Example prompts:

• "Send a welcome email when a user signs up"
• "Track when a user upgrades their plan"
• "Alert me when a user hasn't logged in for 14 days"

The Agent introspects your schema, proposes a feature definition (trigger table, conditions, action), and can deploy it directly. You can refine through conversation.

3. CLI push

The skene CLI analyzes your codebase and generates growth loop definitions locally. Push them to Cloud:

uvx skene analyze .    # Analyze codebase
uvx skene plan         # Generate growth plan
uvx skene build        # Create action definitions
uvx skene push         # Push to Skene Cloud

skene push sends artifacts to POST /api/v1/push, which stores them as a deploy snapshot. Pushed artifacts include the engine manifest, feature registry, and schema analysis — these feed into the Cloud's compile pipeline.

You can also link a GitHub repository on the Agent Engine page. Skene pulls skene/engine.yaml and feature files from the repo and syncs them automatically.

Compiling features

Compilation transforms a feature definition into a deployable state machine. Click Compile on the Actions or Agent Engine page.

During compilation, Skene:

1. Introspects your schema via the connected Supabase project
2. Matches the feature to a target table and operation using LLM-powered schema matching
3. Generates conditions — state checks, cooldown periods, max fire limits
4. Generates effects — state transitions, journey events, metadata updates
5. Derives lifecycle definitions — which stages the feature operates across

Conditions

Conditions control when a feature fires:

Effects

Effects describe what happens when a feature fires:

Deploying to Supabase

After compilation, click Deploy to push triggers to your Supabase project. This requires a read-write Supabase connection.

Each deployed feature creates a Postgres trigger that:

1. Captures row data and enrichment context
2. Sends the event to Skene via pg_net webhook
3. Authenticates with a per-workspace encrypted secret

See Supabase Integration — Deploying triggers for full details on what gets deployed and how trigger reconciliation works.

Feature lifecycle

Features move through these statuses:

Draft → Active ↔ Paused

You can toggle between Active and Paused from the Actions page (or the loop’s detail view). Deleting a feature archives it and removes the trigger from your database.

Feature detail page

Each feature has a detail page where you can configure:

• Trigger — table, operation type, conditions
• Data logic — enrichment joins, related data to fetch
• Action — tool type (email, webhook, analytics, notification), tool-specific config
• Email templates — AI-generated HTML templates for email actions
• Compiler overrides — advanced tuning for conditions and effects
• Test trigger — send a test event to verify the feature works

Next steps

• Logs — Monitor feature decisions and action results
• Supabase Integration — Trigger deployment details
• Schema Analysis — How schema matching works