The guide

Nothing here needs code. You sign in, add a key for the AI model you want to use, and make an agent.

1. Sign in, or create your account. Press Get started. Sign in with email and password, Apple or Google — or press Create an account and enter your name, email, a password, and your role: creator, small business, educator, researcher, or other. The role shapes the first suggestions you see; you can change it later. You start with an empty canvas.
2. Add your AI key. Open the profile menu (bottom left) → API keys. Pick a provider — OpenAI, Anthropic, Google or DeepSeek — and paste a key. The provider bills you for what your agents use; Emidox never marks it up.
3. Create an agent. Press Create agent. Give it a name and a model. Pick a dataset from the left menu for Input, write the Prompt, pick a dataset for Output.
4. Process, read, submit. Press Process. The result appears as a draft. Read it, edit it by hand if you want, and submit it — that sends it to the output. If it isn't right, change the prompt and Process again instead.
5. Save and set the trigger. Save activates the agent in full. On the input, choose Manually, Daily or On update. Daily and On update send without you from then on.

Open any agent and you see three columns: Input, Prompt and Output. That is the whole agent.

• Input is a dataset the agent reads — an Apify scrape, an X account, an Ebiblo input page, an Emidox storage dataset — with files attached if you want. Sources covers each one.
• Prompt is what you want done with it, in three parts: a description, an instruction and examples. Prompts explains how to write each.
• Output is a dataset the result goes to — LinkedIn, X, Telegram, email, an Ebiblo quiz page, or Emidox storage for the next agent. Where the result goes.

Above the columns are the agent's name and model. The name is yours; use the job, not the tool ("Morning posts", not "LinkedIn agent"). The model is the AI that runs the prompt, chosen per agent, from the providers you've added keys for.

At the bottom are three controls, and they are the heart of it:

• Process runs the prompt once, now, on what the input currently holds. Nothing is sent.
• Draft is where the result lands. You read it as the person receiving it would, and you can edit it by hand — cut a line, fix a claim, change the tone. When it reads right, submit it and it goes to the output. That is publishing, and it is always a person's decision on a manual run.
• Save saves the agent and activates its features in full — including its trigger, so a Daily or On-update agent starts sending on its own.

The canvas — the home screen — shows every agent as a row of three nodes with wires between them, and where agents are chained it shows the chain. Zoom and lock controls are at the bottom left.

Every input and output in Emidox is a dataset. Press + in the left rail to add one; the list is Emidox, Email, Ebiblo, Apify, LinkedIn, X.com and Telegram. A dataset appears in the Datasets panel, and each kind goes in one column or the other — the app only lets you drop it where it belongs.

• Apify — input. A scraper you already run on Apify. Its results land as a dataset that grows with each run; the usual source for anything that starts on the web.
• X.com — input and output. As an input, your account's comments, posts and reposts. As an output, publishing.
• Ebiblo — two kinds. An input page (input column) is a page with a public link where a person types, speaks or drops files — it has a title, a sender name, a description and a transcription model for speech. A quiz page (output column) is where a result lands as a question set in Ebiblo. Together they are how Ebiblo runs on Emidox.
• Emidox — input or output. A storage dataset that holds data between agents: one agent writes to it, the next reads from it. This is how chains pass work along.
• Email, LinkedIn, Telegram — output only. See where the result goes.

Files can be attached to any input dataset — documents, spreadsheets, images, whatever the model can read.

Use data from follows the trigger: a manual run uses the most recent update, a daily run uses everything sent to the agent in the last 24 hours, and on update handles each item as it arrives.

A prompt has three boxes. They are not decoration; the model treats them differently.

• Description — one paragraph on what this agent is for and what a good result looks like. Write it the way you'd brief a person on their first day.
• Instruction — the rules. What to do with each input, what to produce, what to leave out, what to do when unsure. Headings and numbered steps work well here; the model follows structure.
• Examples — two or three real inputs with the output you'd want for each. Examples do more than any adjective in the instruction. If you have none, Process once, edit the draft by hand into what you wanted, and paste that pair in.

The rule that earns its place in almost every prompt: if you are not sure, leave it out and say so. It turns a confident wrong claim into a line you can read in ten seconds.

A prompt library — prompts that keep working, kept in one place to reuse across agents — is coming. For now the pattern is to duplicate a saved agent and change its input.

Emidox is not tied to one AI. The model picker on every agent lists whatever providers you've added keys for: OpenAI, Anthropic (Claude), Google (Gemini) and DeepSeek. Other providers are added on request — ask.

Keys live under API keys in the profile menu. Choose the provider, paste the key, press Done. It is stored encrypted and never shown back in full. The provider bills you directly for what your agents use; Emidox adds nothing and never resells tokens.

Which model, when: a cheap, fast one (Gemini Flash, DeepSeek flash, Claude Haiku) for reading, sorting and tagging at volume; a strong one (GPT-5.6, Claude Sonnet or Opus, DeepSeek pro) for drafting anything a person will read as yours. Because the model is set per agent, a chain can use both — cheap first, strong last.

If a run fails, you see the error where you'd expect it — on the agent. Some come from the provider (out of credit, too much text for the model), some from Emidox. Fix the cause and Process again; nothing is silently dropped.

The trigger sits on the input and decides when the agent runs — and whether a person is in the loop.

• Manually. Only when you press Process. The result waits in Draft until you submit it. Uses the most recent update. For agents you're still shaping, and for anything you want to read before it goes out.
• Daily. Once a day at a time and time zone you set, on everything that arrived in the last 24 hours. Anything sent through the day is queued — the button says Queue — and the run's result goes straight to the output.
• On update. The moment something arrives, it is handled and sent. For sources where each item deserves its own answer.
• Off. The agent keeps its settings and does nothing.

One agent does one job. When the work has more than one step, chain agents into a flow: the first writes to an Emidox storage dataset, the next reads from it. The canvas draws the chain, and the Flow switch on an agent shows it in its place in the chain.

Router mode is for the case where the next step depends on the content. Turn it on, connect several agents after the router, and the router agent reads each result and decides which of them gets it — from its prompt, so you can tell it exactly how to choose. Ebiblo uses one router to send material to the right subject agent; the same mechanism carries any branching logic you can describe.

Two things can be paused. Pause the AI model on an agent and data passes from its input to its output untouched — useful for moving something through a flow without processing it. Pause the agent and it stops triggering altogether until you unpause it.

The Output column takes a dataset that publishes. Pick it from the left menu the same way as an input.

• LinkedIn, X.com, Telegram. The result is posted to the connected account, page or channel. The prompt decides format and length; the dataset decides where.
• Email. The result is sent from the connected address — a reply, a report, a digest to whoever should have it.
• Ebiblo quiz page. The result arrives on a quiz page as a question set, where a person approves it before learners see it. Give the page a name that says what it's for — "Reading", "Report to parent", whatever helps you find it.
• Emidox. Storage — the next agent in a flow reads from it.

On Starter, emails an agent sends carry a one-line Powered by Emidox credit at the bottom. Premium removes it. Posts to LinkedIn, X and Telegram never carry it on any plan.

Ebiblo is a separate product — a knowledge-check app where AI drafts questions from a tutor's material, a person approves them, and learners answer on any device. It has its own customers and its own pricing. It contains no AI of its own. Every question it shows a learner was written by an Emidox agent.

The flow: a tutor opens an Ebiblo input page from inside Ebiblo and sends material through it — that page is an Emidox input dataset. A router agent reads the submission and hands it to the right subject agent. That agent checks, rewrites and completes the questions, and its output is an Ebiblo quiz page, where the set waits for a person's approval. It runs on update. Both pages deep-link into Ebiblo, so the tutor never leaves it unless they want to.

What that means if you use both: one sign-in for both apps; the agents behind your quiz pages are on your Emidox canvas to open and edit; and every paid Ebiblo plan includes Emidox Premium, so there is nothing extra to buy. Ebiblo sign-ups also start with a sample agent already made, and their first week runs on our key before they add their own — so an Ebiblo user may never open Emidox at all.

Ebiblo is also the reason to trust the rest of this guide. It is not a demo we built for a page: it is a business running on the same Input → Prompt → Output shape you are about to make. The full story is here.

1. Put something real in the input. Yesterday's scrape, a real mention, a test submission on an Ebiblo input page.
2. Press Process. The agent runs once and the result appears as a draft. Nothing is sent.
3. Read the draft as the recipient. Not "is it correct" — "would I be glad to receive this". You can fix it by hand right there and submit it; but if you're fixing the same thing twice, fix the prompt instead.
4. Run again. Save when two drafts in a row go out without a hand edit.
5. Set the trigger and Save. Then leave it alone for a day and read what it sent.

Editing the draft is the human check. Use it freely on manual runs — that's what it's for. Just remember that Daily and On-update runs skip it.

The profile menu (the green dot, bottom left) holds four things: Upgrade to premium, API keys, Delete account and Log out.

Plans. Starter is free and stays free: up to 20 agents, a small number of chained agents, a subset of integrations, basic support, and a one-line credit on emails. Premium is the paid plan — unlimited agents and chains, every integration, priority support, and no credit line. You see a Starter limit the moment you reach it, in the app; upgrading turns it on. Cancel Premium and you drop back to Starter — agents stay, the ones over the limit stop running. Ebiblo's paid plans include Premium. See pricing.

Keys. One per provider, stored encrypted, deletable from the same dialog. Remove a key and every agent using that provider shows an error until another is added.

Devices. Emidox is a web app today. A mobile app is planned.

Your data. The material that passes through an agent is kept so a run can be repeated and inspected, and goes only to the provider whose key you added and the destination you chose. Deleting an agent deletes its runs; deleting your account deletes everything, keys included.