The prompt and tools are hidden
A locked builder decides how the assistant reasons and what it can call, and the team cannot read, version, or constrain that logic.
Chatbot & AI Agent Builder for real assistants
Shape a support assistant you can inspect before it answers customers
Describe how the assistant answers, which sources it may use, and when it hands off. E-Code structures that behavior in editable source code with prompts, tool contracts, a documentation adapter, and escalation states. Run the interface in Preview, inspect every file, then connect and test the model and services you choose.
Start from the questions your team already answers. Prompts, tool contracts, modeled conversation state, and the running interface remain visible while you iterate.
Live conversation
Assistant replies with sources
A support assistant that answers from documentation, cites what it used, and escalates to a human when confidence is low.
Assistant replies with sources
- Your plan renews on the 1st of each month.
- Reset your API key from Settings → Security.
- I’m not fully sure — connecting you to an agent.Handoff
This inline demonstration shows a conversation thread with cited answers, a handoff on low confidence, and an answer-sources panel in one responsive layout.
From an opaque bot to an assistant you can audit
Chatbot builders feel magical until you need to know why it answered that
A support team needs an assistant that answers from its own documentation, shows its sources, and knows when to escalate. Closed builders hide the prompt, the tools, and the memory, so nobody can review the boundaries or reproduce a bad answer.
Answers drift from the sources
Without a reviewable knowledge base and citations, the bot invents confident answers and there is no way to trace them back to a document.
No boundary between help and harm
When the assistant is unsure, it should hand off to a human — but closed tools rarely let you define, audit, or test that escalation.
E-Code starts from the assistant you describe and lays out its prompt, tool contracts, conversation state, and escalation branches in real source files. You inspect the project, run its interface in Preview, and request the next change without hiding the behavior in a closed builder.
One prompt starts the assistant
Describe the behavior, not the framework
The request below reads like a note from a support lead. The four items map its implementation scope in real source files, not a locked bot builder.
Example prompt
Build an assistant that answers my customers’ questions from my documentation.
- 01
Reviewable prompt and tools
The system prompt, the tools the assistant may call, and their boundaries live in editable files the team can read and constrain.
- 02
Knowledge base answers
A documentation adapter and citation UI model how answers map to sources. You still connect the real corpus and model, then test retrieval quality and citation accuracy.
- 03
Human handoff on low confidence
A routing branch models low-confidence and out-of-scope handoff. Connect it to the support destination your team uses and test that no conversation is lost.
- 04
Preview and audit boundaries
E-Code runs the project interface in Preview across screen sizes. This verifies the generated surface and flow, not a live model, document connection, or production support integration.
Prompt → agent → Preview
See the workflow in a real E-Code run, without pretending this chatbot was captured
The two IDE images below come from the real App Builder salon-booking run. They document the E-Code loop — prompt, Agent plan, generated files, Preview, then correction — while the HelpDesk Copilot above remains a separately authored scenario with fictional data.
This App Builder reference shows the salon prompt and generated booking project inside the real E-Code IDE. It proves the visible prompt-to-Preview workspace flow; it does not show a chatbot, a connected language model, document retrieval, or support handoff.
Open the App Builder IDE reference at full size
The second salon-run capture records a follow-up about a router runtime error and the updated booking Preview. It demonstrates visible Agent iteration, not a successful chatbot generation or a first-pass guarantee.
Open the App Builder IDE reference at full sizeWhat you receive
A reviewable assistant project, from source to live static surface
Source, knowledge-adapter boundary, responsive Preview, and publishing path stay visible. Static interface builds follow E-Code’s supported publishing flow; a model-backed chatbot still needs its own connected services and runtime.
Source you can inspect and export
Prompts, conversation UI, state, and routing live in editable files you can review, version, and take outside E-Code.
Visible knowledge connection point
The documentation adapter and citation model remain explicit in code. No corpus or language model is attached by this page; connect yours and evaluate retrieval before use.
Running responsive Preview
Exercise the chat interface from phone to desktop in Preview. That confirms the rendered flow, not live document retrieval, model output, authentication, or support delivery.
Guided publishing for supported static builds
When the assistant surface qualifies as a supported static build, E-Code guides the build and publishing steps without presenting unconnected server behavior as deployed.
Live URL with a clear runtime boundary
Publish the supported static interface to an E-Code live URL. A chatbot that calls a model, reads documents, or stores conversations requires the exported project and an appropriate deployed backend runtime.
Iteration through the Agent conversation
Continue in plain language, inspect the resulting file changes, and rerun Preview after each adjustment to the assistant experience.
Built for real assistants
Everything a support assistant needs, in code you control
The Chatbot Builder path keeps prompt, tools, memory, and escalation in one inspectable workflow.
Answers from your docs
Start with a source-adapter contract and citation presentation, then connect your corpus and test every retrieval path.
Reviewable prompts
The system prompt and behavior rules live in editable files, not a locked builder.
Declared tools
Every tool the assistant may call is declared and bounded in code you can audit.
Memory you can inspect
Conversation state is modeled in the project so you can review what is retained and replace it with an appropriate store.
Human handoff
Define the branch for low-confidence or out-of-scope requests, then connect and test the real support queue.
Exportable project
Export the source files or keep building in E-Code; review the terms of every model and external service you add.
Who builds with it
Four support-assistant patterns to shape in editable code
These are practical starting points for an editable assistant project; each needs its own source connection, model evaluation, and operational testing.
Documentation support bots
Answer customer questions from product docs and escalate on low confidence.
Internal help desks
Assistants that answer IT, HR, or ops questions from internal knowledge bases.
Task and workflow agents
Agents that call bounded tools to complete steps and report back for review.
Onboarding assistants
Guided assistants that walk new users through setup with cited sources.
Common questions
Chatbot Builder, answered honestly
What the Chatbot Builder path produces, and where its boundaries are.
Do I get real code or a locked bot builder?+
You get editable source files for prompts, tools, state, and routing that you can read, version, and export. Any model, vector store, or support service you connect remains governed by that provider’s terms.
Does it answer from my own documentation?+
The generated assistant is modeled to retrieve from a knowledge base and cite what it used. The inline demonstration on this page uses fictional data and no connected model or backend.
Can it hand off to a human?+
The project can model escalation on low confidence or out-of-scope questions. A real handoff requires connecting your support destination and testing delivery, ownership, retries, and failure states.
Can I connect a real model or knowledge base?+
The generated tools and knowledge model are code you can wire to your own model and sources. Nothing on this page is connected to a live model — the demo is fictional.
How do I change the assistant later?+
Edit the prompt, tools, or rules directly, or ask the Agent for the next change and review the diff against the running Preview.
Chatbot & AI Agent Builder for real assistants
Describe your assistant and see it running
Turn the questions your team answers into an editable conversational project with reviewable prompts, tool contracts, state, and handoff logic. Preview the interface, then connect and test the external services it depends on.