Disclaimer

“Developer” means an individual or organization using Asiyst developer services.

“Developer Application” means an application, website, software product, service, script, integration, or other system developed using Asiyst developer services.

“Developer Account” means the Asiyst account used to access developer functionality.

“API” means an application programming interface provided by Asiyst.

“SDK” means a software development kit or related development library provided by Asiyst.

“CLI” means a command-line interface or developer tool provided by Asiyst.

“Developer Credentials” means API keys, tokens, secrets, authentication credentials, or other credentials used to access developer services.

“Developer Content” means code, applications, prompts, configurations, data, files, knowledge sources, and other content submitted or transmitted by a Developer through the developer services.

You may use Asiyst developer services only if you are authorized to enter into applicable agreements and use the relevant Services.

If you use Asiyst on behalf of an organization, you represent that you have authority to act on behalf of that organization.

You may need an Asiyst account and an authorized project to use certain developer functionality.

You are responsible for:

• Maintaining accurate account information.
• Protecting your account.
• Managing authorized users.
• Protecting Developer Credentials.
• Reviewing project permissions.
• Monitoring API activity.
• Complying with applicable terms.

You must not allow unauthorized persons to access developer functionality through your account.

Developer Credentials are confidential authentication information.

You must:

• Store credentials securely.
• Avoid exposing private credentials in source code.
• Avoid committing secrets to public repositories.
• Restrict credential access.
• Rotate compromised credentials.
• Revoke unused credentials.

You must not:

• Sell credentials.
• Share credentials with unauthorized users.
• Use another person's credentials.
• Attempt to obtain credentials without authorization.
• Circumvent credential restrictions.

Developers are responsible for determining whether credentials can safely be used in client-side applications.

Private credentials should generally not be embedded in publicly accessible:

• Browser code.
• Mobile application bundles.
• Public repositories.
• Static websites.
• Other environments where credentials can be extracted.

Where server-side authentication is required, Developers should use an appropriate server-side architecture.

Use of Asiyst APIs is governed by these Developer Terms and the Asiyst API Terms.

Developers must follow:

• API documentation.
• Authentication requirements.
• Rate limits.
• Usage limits.
• Version requirements.
• Security requirements.
• Applicable restrictions.

Undocumented API behavior should not be treated as guaranteed functionality.

Asiyst may provide SDKs to simplify integration with the Services.

SDKs may include:

• Client libraries.
• Server libraries.
• Browser integrations.
• Framework integrations.
• Components.
• Utilities.
• Examples.
• Type definitions.

SDK behavior may vary by version.

Developers are responsible for using supported SDK versions and following applicable documentation.

Asiyst may provide command-line tools for developer workflows.

CLI functionality may include:

• Authentication.
• Project configuration.
• Application setup.
• SDK installation.
• Deployment-related operations.
• Diagnostics.
• Project management.

Developers are responsible for executing CLI commands in environments they control or are authorized to manage.

You are responsible for applications you create using Asiyst developer services.

Your responsibility includes:

• Application functionality.
• Application security.
• User authentication.
• Authorization.
• Data protection.
• User-generated content.
• Third-party integrations.
• Compliance with applicable laws.
• Your application's terms and policies where applicable.

Asiyst does not assume responsibility for your application merely because it uses Asiyst technology.

If your application is made available to third parties, you are responsible for providing users with appropriate information concerning:

• Your application's functionality.
• Data collection.
• Data processing.
• AI-generated content.
• Applicable terms.
• Privacy practices.
• User responsibilities.

You must obtain any consent or authorization required by applicable law.

You retain rights you otherwise have in Developer Content, subject to applicable agreements and law.

By submitting Developer Content to Asiyst, you authorize Asiyst to process that content as necessary to provide the Services and perform the functions you request.

Additional data-processing provisions may apply under the Asiyst Privacy Policy and Data Processing Agreement.

Developers are responsible for ensuring they have appropriate rights to use content submitted through Asiyst.

This includes:

• Images.
• Videos.
• Audio.
• Text.
• Documents.
• Product information.
• Website content.
• Customer information.
• Software.
• Other third-party materials.

You must not use Asiyst developer services to facilitate unauthorized infringement.

Asiyst and its licensors retain rights in:

• Asiyst software.
• APIs.
• SDKs.
• CLI tools.
• Documentation.
• Interfaces.
• Trademarks.
• Designs.
• Proprietary technology.

These Developer Terms do not transfer ownership of Asiyst intellectual property to you.

You retain ownership of code you independently create, subject to any third-party licenses or other applicable rights.

Using an Asiyst SDK, API, or development tool does not automatically transfer ownership of your application code to Asiyst.

You remain responsible for complying with applicable open-source and third-party software licenses.

Asiyst developer tools may include or depend on open-source software.

Applicable open-source components may be governed by their own licenses.

Where required, applicable license notices or attribution information may be provided with the relevant software or documentation.

You may configure supported Asiyst functionality according to the available developer documentation.

You must not modify or interfere with Asiyst systems in ways that:

• Circumvent security.
• Bypass access controls.
• Defeat usage limits.
• Interfere with other users.
• Compromise infrastructure.
• Violate applicable law.

Except where expressly permitted by applicable law, you must not reverse engineer, decompile, disassemble, or attempt to extract protected source code or security mechanisms from Asiyst software.

Nothing in these Terms restricts rights that cannot legally be restricted under applicable law.

Developer services may be subject to:

• API rate limits.
• Request quotas.
• Credit limits.
• Token limits.
• Storage limits.
• Concurrent-request limits.
• Project limits.
• Other technical restrictions.

You must not circumvent these restrictions.

Applications should implement appropriate:

• Timeouts.
• Retry policies.
• Exponential backoff.
• Error handling.
• Request throttling.

Developers should avoid creating uncontrolled request loops or unnecessary traffic.

Developers are responsible for securing their applications and integrations.

Reasonable security practices may include:

• Secure secret management.
• Authentication.
• Authorization.
• Encryption where appropriate.
• Input validation.
• Output validation.
• Dependency management.
• Logging.
• Monitoring.
• Access controls.
• Credential rotation.

If you discover a security vulnerability involving Asiyst developer services, you should report it through the appropriate Asiyst security contact.

You should not exploit a vulnerability beyond what is reasonably necessary to confirm and report the issue.

You should avoid accessing, modifying, deleting, or exposing another user's information.

If your application uses Asiyst AI functionality, you are responsible for ensuring that the application's use complies with:

• AI Usage Policy.
• Acceptable Use Policy.
• Applicable laws.
• Applicable third-party provider terms.

AI-generated information should be reviewed before being used for consequential purposes.

AI output may be:

• Inaccurate.
• Incomplete.
• Inconsistent.
• Outdated.
• Misleading.
• Unsuitable for a particular purpose.

Developers are responsible for implementing appropriate validation and safeguards before presenting AI output to end users or using it to trigger automated actions.

Developers should use additional safeguards when AI functionality contributes to decisions that may significantly affect individuals.

Depending on the application, safeguards may include:

• Human review.
• Verification.
• Auditability.
• Error handling.
• User notification.
• Appropriate appeal or correction mechanisms.

Developers are responsible for determining and complying with applicable legal requirements.

If you use Asiyst to create AI assistants or avatars, you are responsible for configuring them appropriately.

This includes:

• Defining appropriate behavior.
• Configuring knowledge sources.
• Managing permissions.
• Reviewing generated responses.
• Protecting user information.
• Providing appropriate user disclosures.
• Preventing prohibited uses.

An AI avatar does not independently create legal authority for actions it performs.

Developers may connect websites, documentation, files, databases, or other supported knowledge sources.

You are responsible for ensuring that:

• You have the right to access the source.
• You have the right to process the content.
• The content may lawfully be used for the intended purpose.
• Personal information is processed appropriately.
• Connected sources are properly secured.

You are responsible for the accuracy, legality, and appropriateness of data submitted through your application.

You must not intentionally submit information that you are prohibited from processing or transmitting.

If your application processes personal information through Asiyst, you are responsible for complying with applicable privacy and data-protection laws.

This may include obligations concerning:

• Notice.
• Consent.
• Lawful basis.
• Data minimization.
• Security.
• Retention.
• Deletion.
• Data-subject rights.
• International transfers.

Developers must comply with applicable requirements concerning children's information.

You should not knowingly use Asiyst developer services to process children's information in violation of applicable law.

Where a product is intended for children, appropriate safeguards and legal requirements must be evaluated before deployment.

Developer applications may integrate with third-party services.

Developers are responsible for reviewing and complying with applicable third-party:

• Terms.
• Privacy policies.
• API requirements.
• Security requirements.
• Licensing requirements.
• Data-processing requirements.

If you allow users to connect third-party API credentials through your application, you are responsible for implementing appropriate security and authorization controls.

You must not expose user credentials unnecessarily or use them for purposes beyond the user's authorization.

Developer usage may consume applicable Asiyst credits or incur applicable charges.

Developers are responsible for monitoring their usage and maintaining appropriate account or credit balances where required.

Usage measurements may include:

• API requests.
• Tokens.
• Credits.
• Model usage.
• Processing activity.
• Project activity.

Applicable pricing and billing terms govern charges.

You must not attempt to avoid applicable charges by:

• Creating unauthorized accounts.
• Rotating credentials to avoid usage limits.
• Manipulating requests.
• Exploiting billing errors.
• Circumventing usage measurement.
• Using unauthorized access methods.

Asiyst may monitor developer-service usage for purposes including:

• Security.
• Abuse prevention.
• Fraud detection.
• Reliability.
• Usage measurement.
• Billing.
• Debugging.
• Legal compliance.

Monitoring does not necessarily mean that Asiyst reviews all Developer Content manually.

Asiyst may suspend or restrict developer access where reasonably necessary to:

• Protect the Services.
• Protect users.
• Prevent abuse.
• Address security issues.
• Enforce usage limits.
• Investigate violations.
• Comply with legal requirements.

Where reasonably practicable, Asiyst may provide notice, but immediate restrictions may be applied where necessary to protect security or availability.

Developer access may terminate if:

• Your account is closed.
• Your applicable agreement ends.
• Developer access is revoked.
• You violate applicable terms.
• Asiyst discontinues the relevant developer service.
• Termination is otherwise permitted under the applicable agreement.

Following termination, you must stop using applicable developer services and credentials.

Asiyst may modify developer services over time.

Changes may include:

• API versions.
• SDK versions.
• CLI functionality.
• Authentication mechanisms.
• Documentation.
• Endpoints.
• Models.
• Integrations.
• Usage limits.
• Supported technologies.

Where reasonably practicable, Asiyst may provide information concerning material changes or deprecations.

Developers must not rely on undocumented functionality as a guaranteed part of the Services.

Undocumented endpoints, internal interfaces, private APIs, or other non-public functionality may be changed or removed without notice.

Developer features identified as beta, preview, or experimental are subject to the Asiyst Beta / Experimental Features Terms.

Such functionality may be incomplete, changed, suspended, or discontinued.

Asiyst does not guarantee uninterrupted availability of developer services unless an applicable agreement expressly provides otherwise.

Availability may be affected by:

• Maintenance.
• Infrastructure failures.
• Third-party services.
• Security events.
• Network failures.
• Capacity limitations.
• Other operational circumstances.

Support availability may depend on the Developer's plan, Service, or applicable agreement.

Documentation and self-service resources may be provided for certain developer products.

Asiyst does not guarantee that every developer integration will receive customized technical support.

Developers may provide feedback concerning APIs, SDKs, CLI tools, documentation, and other developer functionality.

Asiyst may use such feedback to improve its Services, subject to applicable law and contractual obligations.

Asiyst does not guarantee that every Developer Application will remain compatible with every future version of the Services.

Developers are responsible for maintaining their applications as supported APIs, SDKs, operating systems, browsers, frameworks, and third-party dependencies change.

Developers are responsible for complying with all laws and regulations applicable to their applications and users.

This may include laws relating to:

• Privacy.
• Data protection.
• Consumer protection.
• Intellectual property.
• Advertising.
• Communications.
• Accessibility.
• Export controls.
• Industry-specific requirements.

Certain Asiyst developer functionality may not be available in every country or jurisdiction.

Developers are responsible for ensuring that their use of the Services complies with applicable geographic restrictions and laws.

Unless expressly authorized by Asiyst, Developers may not resell or sublicense Asiyst developer services as a standalone service that provides unauthorized third parties with access to Asiyst resources through the Developer's credentials.

Developers may build applications using Asiyst technology where permitted by the applicable Services and agreements.

Developers must respect third-party intellectual-property rights.

Complaints involving content or applications may be handled under the Asiyst Copyright / DMCA Policy, Intellectual Property Policy, Trademark Policy, or other applicable policies.

Any indemnification obligations relating to Developer use of Asiyst Services are governed by the applicable Terms of Service, enterprise agreement, order form, or other contractual agreement.

Nothing in these Developer Terms independently creates an indemnification obligation unless expressly stated.

Developer services are provided subject to the applicable Asiyst agreements.

Except where expressly provided in an applicable agreement, Asiyst does not guarantee that:

• Developer services will be uninterrupted.
• APIs will remain unchanged.
• SDKs will remain compatible with every environment.
• AI output will be accurate.
• Developer Applications will achieve a particular result.
• Third-party integrations will remain available.

Any limitations of liability applicable to developer services are governed by the applicable Terms of Service or other contractual agreement.

Nothing in these Developer Terms is intended to exclude liability that cannot lawfully be excluded or limited.

These Developer Terms supplement the Asiyst:

• Terms of Service.
• API Terms.
• AI Usage Policy.
• Acceptable Use Policy.
• Privacy Policy.
• Security Policy.
• Intellectual Property Policy.
• Copyright / DMCA Policy.
• Beta / Experimental Features Terms.
• Other applicable Service-specific terms.

Where a specific agreement governs a particular developer service, that agreement may control to the extent of any conflict.

Asiyst may update these Developer Terms to reflect changes in:

* Developer products. * APIs. * SDKs. * CLI tools. * Legal requirements. * Security practices. * Service architecture. * Operational practices. Updated terms will be made available through the Asiyst Services.

For questions regarding these Developer Terms or Asiyst developer services, contact:

Asiyst Website: https://asiyst.com Email: support@asiyst.com