LogoLogo
  • Whitepaper
    • Introduction
  • Challenges & Solution
  • Tokenomics
  • Roadmap
  • Product docs
    • Ai Assistant - Scrappy
      • Tech Framework
      • API
  • Gear-Up Studio (Individuals)
    • Tech Framework
    • Getting Started
      • Templates
      • Contracts Library
    • Testing Playground
    • Deploy & Use
    • Contract Use Cases
  • Gear-Up Factory (Developers)
    • Tech Framework
    • Closed Source Testing
    • Marketplace
    • Earn-Per-Deploy Model
    • Earn-Per-License Model
    • Terms & Conditions
  • Gear Flow (Plugin & App)
    • Tech Framework
    • More To Be Announced
  • GUIDE
    • Security
    • Socials
    • Extended Vision
    • FAQs
Powered by GitBook
On this page
  • 🤖 What is Scrappy?
  • 🧠 Core Intelligence Stack
  • 🧱 Studio Mode: For Individuals
  • 💻 Factory Mode: For Developers
  • ⚙️ Context-Aware Engine
  • 🔐 Safety & Security
  • 🧪 Live Preview & Simulation Support
  • 🗺️ Future Capabilities
Export as PDF
  1. Product docs
  2. Ai Assistant - Scrappy

Tech Framework

PreviousAi Assistant - ScrappyNextAPI

Last updated 1 month ago

An AI-powered co-pilot for building, testing, and optimizing smart contracts inside GearUp.

Scrappy is the intelligent assistant embedded across GearUp Studio and GearUp Factory. It’s not just a chatbot — it’s a dynamic AI system that understands contract composition, EVM logic, template schema, and developer workflows. Scrappy enhances both non-technical user experience and developer productivity through contextual awareness, secure interaction, and smart code guidance.


🤖 What is Scrappy?

Scrappy is a real-time, context-aware assistant designed to:

  • Explain smart contract logic in simple terms

  • Suggest block combinations and fixes

  • Help with testing and error resolution

  • Convert natural language to Solidity code

  • Validate logic, parameters, and deployment safety

Scrappy functions differently in GearUp Studio (for individuals) and GearUp Factory (for developers), adapting based on environment and user intent.


🧠 Core Intelligence Stack

Scrappy is built on a hybrid AI architecture combining several industry-grade models:

Layer
Technology Used
Purpose

Language Model

OpenAI GPT-4, Claude 3 Opus

Natural language understanding

Code Engine

Meta Code Llama, Google AlphaCode

Solidity-specific generation & diagnostics

Vector Embedding

FAISS + OpenAI Embeddings

Fast prompt retrieval & document memory

Contextual Agent

LangChain + RAG (Retrieval Augmented Gen)

Adapts answers to Studio or Factory context

Chain Simulator

Ethers.js + Hardhat Sandbox

Simulates contract output for preview

Security Overlay

GPT Validator + Custom Rule Engine

Scans for known vulnerabilities

Scrappy processes user input using semantic parsing and passes it through contextual decision logic to determine whether the task involves text, logic, Solidity code, templates, deployment, or testing.


🧱 Studio Mode: For Individuals

In GearUp Studio, Scrappy serves as a no-code enabler:

**Capabilities in Studio Mode**
- Explain what each block does
- Recommend which blocks to add next
- Autofill parameters with suggested values
- Simulate what the contract will do
- Warn about missing triggers or risky logic

Prompt examples:

  • "What does LiquidityProvisionBlock do?"

  • "Make me a basic token with 10% tax"

  • "Will this contract run every 24 hours automatically?"


💻 Factory Mode: For Developers

In GearUp Factory, Scrappy operates in a more technical role:

**Capabilities in Factory Mode**
- Explain Solidity syntax and inheritance chains
- Debug compile-time and runtime errors
- Suggest code improvements for gas/security
- Generate full functions or schema from prompts
- Validate schema.json and metadata.yaml files

Prompt examples:

  • "Add a time-lock function to this ERC20"

  • "Why is this onlyOwner function unsafe?"

  • "Write a constructor with tax and treasury inputs"


⚙️ Context-Aware Engine

Scrappy understands where you're working and adapts accordingly:

Context
Awareness Level

Studio (Blocks)

Contract block schema, user params

Studio (Deploy)

Wallet role, testnet vs mainnet

Factory (Code Editor)

Contract syntax, dependency tree

Factory (Test Mode)

Execution logs, gas traces

It doesn't just answer — it thinks within your workspace.


🔐 Safety & Security

  • Scrappy cannot deploy contracts — it only suggests or simulates

  • No wallet data or private keys are processed or stored

  • Security-level prompts are reviewed through rule-based scanning before displaying outputs

  • Uses LLM “content filtering” for safe generation in shared environments

Scrappy is also integrated with internal AI review pipelines, allowing contracts generated or influenced by Scrappy to be flagged for manual audit before being published or deployed.


🧪 Live Preview & Simulation Support

Scrappy integrates with the Hardhat local environment to simulate:

  • Token transfers

  • Contract execution flows

  • Gas costs under different conditions

  • Reverts and function edge cases

Simulations return readable summaries like:

✅ This contract will trigger every 24 hours.
🧾 On success, it will send 5% of Token A to address 0xabc...
⚠️ If the wallet has less than 0.2 ETH, the trigger will fail.

🗺️ Future Capabilities

🚧 Coming soon to Scrappy:

  • Real-time audit scoring and AI-powered risk scorecard

  • Full-code template generation from one-line prompts

  • Collaborative prompts (multiple users working on same logic)

  • Voice-based commands for Studio interactions


Scrappy is built to support the entire smart contract lifecycle — from beginner questions to advanced Solidity optimization.

Whether you're building with blocks or writing line by line, Scrappy is the smartest teammate in Web3.


Scrappy. Built on AI. Trained for DeFi. Made for builders.

Overview
Preview