In development

RADS is being built now. It is not available yet.

RADS

Free-tier AI framework

Serious software, without a serious AI budget.

The agentic AI tools that build real software can cost more than many people can pay. RADS exists so you can build complex, useful applications anyway, using the free tiers of AI chat services and a small model running on your own computer.

RADS is an advanced orchestration framework under active development by Agentic Applications. Specifically engineered to maximize the operational capacity of free-tier AI sessions, it enforces a strict Research, Architect, Develop, and Self-Learn lifecycle to reliably execute complex software development tasks.

  1. Who does each job in RADS An orchestrator on your machine runs the loop and hands each job to one of three workers. A free chat session does the creative work: research, architecture and development. A small model on your own computer does planning, review, self-learning and the write-up. Plain tools with no AI do the build, test, lint and indexing. Orchestrator on your machine · runs the loop Free chatsession Small localmodel Plaintools ResearchArchitectDevelop PlanReviewSelf-LearnWrite-up BuildTestLintIndex creative on your PC no AI at all
    Illustration

    The right worker for every job

    An orchestrator on your own machine runs the whole loop in code, not in chat. It saves the free chat session for the creative work, hands planning, review and learning to a small model on your own computer, and gives builds and tests to plain tools that need no AI at all. Your free session goes further, and no paid plan is needed.

  2. The RADS lifecycle, with proof at every phase Seven phases run in order: Research, Architect, Plan, Develop, Build and test, Review, and Self-Learn, then the loop returns to Research for the next task. Research, Architect and Develop run in the free chat session, Build and test runs on plain tools, and the rest run on the small local model. Every phase leaves a proof mark before the next one starts. Phase Runs on Proof Researchchat session Architectchat session Planlocal model Developchat session Build & testplain tools Reviewlocal model Self-Learnlocal model
    Illustration

    A strict lifecycle, with proof at every step

    Every task runs Research, Architect, Develop and Self-Learn, with planning, build, test and review in between. Each phase has to leave proof that it really ran before the next one starts, and when something it needs is not there, the run stops instead of faking a result.

  3. One task across several free sessions Three free chat sessions run one after another, each ending when its free limit is reached. Each session hands its work to your machine, which keeps the saved state, the plan and review, the build and test results, the learned memory and the proof log. The next session starts from that saved state. Session 1Research · Architect free limit reached Session 2Develop free limit reached Session 3the next task Your machine saved state plan · review build · test memory proof log
    Illustration

    Many free sessions, one finished task

    Free tiers run out. RADS plans for it: the task's state, plan, test results and proof live on your machine, not in the chat, so when one session hits its limit the next one restores where things stand and carries on.

  4. How RADS learns across projects One central RADS install sits above three projects that link to it instead of copying it. Each project keeps its own local memory. When a project finishes, its lessons go up to the central install, and the rules and know-how come back down to every project. RADS framework one central install lessons know-how Project Alocal memory Project Blocal memory Project Clocal memory
    Illustration

    It gets smarter with every project

    Self-Learn pulls the patterns out of each run into a local memory that later phases search, instead of rereading whole files and burning tokens. When a project wraps up, its lessons go back to one central RADS install that every project links to, so the next build starts out knowing more.

Under the hood

  • Works with the chat you useThe creative steps are vendor-neutral, so any capable chat assistant can take them on
  • Grounded, not guessedGrounding and verification gates check the work before a phase can pass
  • Kind to your computerIt watches graphics and system memory and pauses heavy work rather than crash the machine you are working on
  • Runs on your own PCWindows with an NVIDIA graphics card, RTX 30 series or newer recommended