Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Ritc, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fritc.io%2Fritc-main" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fritc.io%2Fritc-main" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
What an agent can do with Ritc API.
Compose a rule from triggerIds and actionIds and set its status
Run a single rule, a rule group from a list of rule ids, or all active rules in an app
Stop rule-group execution early with the break_when_rule_fires query flag
Define triggers and actions that call a channel function with parameters
Register channels and the functions each channel exposes
GET STARTED
Assign app users to channels and rules, then run a rule for one user
Store external API credentials per channel for an app
Patterns agents use Ritc API for, with concrete tasks.
★ Agent-triggered rule execution
A developer has encoded business logic as Ritc rules and wants an agent to fire them at the right moment rather than reimplementing the logic in prompts. Through Jentic the agent searches for 'run a Ritc rule', loads the runRule operation, and calls POST /rules/{rule_id}/run with the API key added by the developer's own instance. The rule's triggers and actions then execute on Ritc as defined.
Call GET /rules to find the rule named 'late-invoice-reminder', then call POST /rules/{rule_id}/run with that rule's id
Building a rule from triggers and actions
A new automation is assembled in three steps: create a trigger with POST /triggers (name, channelId, and functionId are required), create an action with POST /actions using the same required fields, then create the rule with POST /rules passing triggerIds and actionIds. The rule can be updated later with PATCH /rules/{rule_id} or removed with DELETE /rules/{rule_id}.
Call POST /triggers with name 'order-over-500', channelId 'shop', and functionId 'fn-001', call POST /actions with name 'notify-sales', channelId 'mail', and functionId 'fn-002', then call POST /rules with both ids in triggerIds and actionIds
Batch evaluation of an app's rules
When an event arrives that several rules could match, POST /apps/rules/run evaluates every active rule in the app, and POST /apps/rulegroup/run/{rule_id_list} runs only a chosen list. Both accept break_when_rule_fires so evaluation can stop at the first rule that fires, which keeps mutually exclusive rules from all acting on the same event.
Call POST /apps/rulegroup/run/{rule_id_list} with rule_id_list '12,13,14' and break_when_rule_fires true
Per-user rule assignment
Rules can target individual app users. POST /users creates an app user, POST /users/{user_id}/rules/{rule_id} assigns a rule to them, and POST /users/{user_id}/rules/{rule_id}/run executes that rule for that user only, with GET /users/{user_id}/rules listing what the user is subscribed to.
Call POST /users/{user_id}/rules/{rule_id} to assign rule 7 to user 'u-981', then call POST /users/{user_id}/rules/{rule_id}/run for the same pair
66 endpoints — the ritc api runs business rules in the cloud: it links triggers to actions through channels and executes them on request.
METHOD
PATH
DESCRIPTION
/rules
Create a rule
/rules/{rule_id}/run
Run a rule
/apps/rules/run
Run active app rules
/apps/rulegroup/run/{rule_id_list}
Run a rule group
/triggers
Create a trigger
/actions
Create an action
/channels/{channel_id}/functions
List channel functions
/users/{user_id}/rules/{rule_id}/run
Run a rule for a user
/rules
Create a rule
/rules/{rule_id}/run
Run a rule
/apps/rules/run
Run active app rules
/apps/rulegroup/run/{rule_id_list}
Run a rule group
/triggers
Create a trigger
/actions
Create an action
/channels/{channel_id}/functions
List channel functions
/users/{user_id}/rules/{rule_id}/run
Run a rule for a user
What agents get from Jentic-routed access to this vendor.
Setup
Wiring Ritc by hand means building its Authorization header as a Base64-encoded API key with a trailing colon, then learning how rules, triggers, actions, channels, and functions reference each other by id. Through Jentic you install once, import Ritc from the API Directory, store the key once, and your agent calls it.
Permission scoping
Ritc puts the rule id in the URL path (/rules/{rule_id}/run), so a rule in Jentic can pin your agent to running specific Ritc rules. You choose the operations it may call, so destructive ones like DELETE /channels/{channel_id} or removing external credentials are not included unless you add them.
Credential isolation
Your Ritc API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'run a rule' or 'create a trigger', and Jentic returns the matching Ritc operation with its input schema, including required fields like channelId and functionId.
Alternatives and complements available in the Jentic catalogue.
Specific to using Ritc API through Jentic.
What authentication does the Ritc API use?
The Ritc OpenAPI spec declares an apiKey scheme sent in the Authorization header. Its description says Ritc treats this as HTTP Basic with the API key as the username and an empty password, in the form Base64encode(api-key:), and also accepts the key as plaintext. Through Jentic the key is stored by your own instance and added to the header at call time.
Can I run several Ritc rules at once?
Yes. POST /apps/rules/run runs every active rule in the app, and POST /apps/rulegroup/run/{rule_id_list} runs only the rules you list in the path. Both take a break_when_rule_fires query parameter that stops evaluation once a rule fires.
What are the rate limits for the Ritc API?
The OpenAPI spec does not specify rate limits. Check the Ritc site at https://ritc.io/ for current limits on your plan.
Is there a Ritc MCP server?
You do not need an MCP server to give your agent Ritc. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent finds operations like runRule or addTrigger by intent when it needs them.
How do I run a Ritc rule through Jentic?
Search Jentic for 'run a Ritc rule', load the POST /rules/{rule_id}/run operation, and execute it with the rule id. Use GET /rules first if the agent only knows the rule's name. To run it on your own infrastructure, install Jentic One from its GitHub repo.
Can I limit what my agent is allowed to do with the Ritc API?
Yes. Write a rule that allows only GET /rules and POST /rules/{rule_id}/run for the rule ids you choose, so the agent can look up and fire those rules but cannot edit triggers, delete channels, or touch external credentials, and every call it makes is logged.
Know of an official OpenAPI document? Contribute it →
For Agents
Define Ritc rules from triggers and actions, attach them to channels and users, and run a rule, rule group, or an app's active rules on demand.
Use for: Run the Ritc rule with id 42, I need to create a rule that links a trigger to an action, Run all active rules in my app and stop at the first one that fires, List all triggers defined in my Ritc app
Not supported: Does not host application code, send email or SMS itself, or schedule cron jobs. Use for defining and running trigger-and-action rules on Ritc only.
The Ritc API runs business rules in the cloud: it links triggers to actions through channels and executes them on request. A rule bundles triggerIds and actionIds, each trigger and action points at a channelId and functionId, and channels expose the functions an app can call. Rules run one at a time, as a rule group, across every active rule in an app, or for a single app user, with an option to stop when the first rule fires.
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
Base layer of spec validity and structural soundness.
Aggregated quality score from linter diagnostics, weighted by severity.
Percentage of `$ref` references that resolve successfully.
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
Structural correctness score based on schema issues using logarithmic dampening.
Clarity, completeness, and ingestion readiness for developers and tooling.
How richly the API is illustrated with examples.
Percentage of examples that conform to their schemas.
Percentage of operations with complete response definitions (success, client error, server error).
Health of API ingestion, bundling, and resolution within Jentic pipelines.
Semantic breadth, depth, and agent comprehension for AI systems.
Coverage of descriptions across API elements.
Coverage of RFC 9457 Problem Details for error responses.
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
Coverage of summaries across operations/tags/info.
Functional utility, complexity comfort, and AI orchestration readiness.
Agent comfort level based on API operational and structural complexity.
Trust, risk posture, and security compliance.
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
Findability, semantic richness, and reasoning readiness.
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>