How an AI agent works, from the smallest part up.

In more detail

• Variation is normal, not a bug: AI agents work by probabilities, so they may not always produce identical results, and people building with them are told to expect that.
• A system can be built to say “I'm not sure” when the evidence is thin, rather than make something up: one Bitdeer example tells a support assistant to answer only from the text it was handed, and to say it does not know if that text lacks the answer.
• The other fix comes in part 3a: let it look things up instead of guessing. Bitdeer's articles call this retrieval, fetching the right documents when the question arrives so the reply rests on them, which cuts down on made-up answers.
• Whether a system makes up a plausible answer or cites the right policy is not a question of which model it uses. It is a question of how the knowledge behind it is set up.
• Wrong answers can hide inside step-by-step reasoning too: a model can invent a step or a conclusion and carry it forward with high confidence.

In more detail

• The limit covers what goes in and what comes out together: it is the most text the model can handle in one request, the question plus the reply.
• A builder can also cap how long a reply may be, because the reply uses up room in the window and adds cost and waiting.
• Managing context (what the model is given), memory design and how the work fits together is described as becoming as important as the model itself.
• A long window has a physical cost: the longer the chat and the more people using the model at once, the less chip memory is left for everything else.
• Some models Bitdeer AI hosts accept windows of up to a million tokens. Bitdeer's own article notes that most models with large advertised windows become uneconomical well before the limit, and says its hybrid design keeps a million-token window usable in production.

In more detail

• Instructions guide the model, but they are words, and a rule that only lives in words is only as firm as the wording. Bitdeer's write-up on OpenShell describes enforcing rules at the runtime level, in the program that runs the agent, instead of relying solely on prompts or guardrails inside the agent (part 7i).
• An instruction can be short: Bitdeer's sample call sets the whole job with one line, “You are a knowledgeable assistant. Provide concise and clear explanations to scientific questions.” A rule about outdoor seating would be one more line like it.
• Bitdeer's guardrails article lists “intent alignment”, keeping an agent within its defined objectives, ethical limits and domain rules, as a key function of guardrails, and lists prompt templates (a set layout for requests) as a way to reduce unpredictability.
• Because the instruction rides along on every call, a long one is paid for again each time: longer prompts cost more, and trimming unnecessary words helps.

In more detail

• It can check its own work before replying, a pattern Bitdeer's blog calls reflection: the agent produces a first answer, critiques it, then revises it.
• Looking can repeat: some agents reflect on their output several times, improving it with each pass, and adapt to what they find along the way.
• Each look can shape the next step: in a multi-step search, each step has its own question, informed by what the previous step found, like asking about 7:30 once 7pm comes back full.
• Looking is also how an agent recovers: one Bitdeer write-up points to a public test that measures how well a model can chain commands, read the output and recover from errors across many steps.
• Retrying belongs to the loop too, when the fault is a busy service: Bitdeer's error guide marks a “too many requests” reply as safe to retry after a short wait, and a malformed request as not worth repeating.

In more detail

• Reusable skill files are written the same way: in the agent framework Bitdeer's guide describes, a skill is plain text, and more than 100 ready-made ones are available.
• In the same framework, memory is a set of ordinary text files kept locally by default, so you can open them and read what the agent remembers.
• True long-term memory, where an agent remembers people and keeps learning over time, is described in Bitdeer's article on the agent economy as a complex hurdle that still needs advances in how information is stored and retrieved.
• Once the notes grow to years of past bookings, a program can search them and bring in only the few that matter tonight, such as the usual table size and any allergy, instead of reading every past dinner. Bitdeer describes this as plug-in storage for memory and retrieval that lets agents build up context over time.

In more detail

• A heartbeat is a timer that wakes the agent regularly to check whether there is work to do: in Bitdeer's guide, a built-in heartbeat lets the agent monitor tasks and act without anyone prompting it.
• Running an agent on your own laptop means it stops whenever the machine shuts down, and Bitdeer's guide adds two more risks: fiddly setup and keys stored on the device.
• An always-on home need not cost much: for the small computer an agent needs, Bitdeer's guide lists pay-as-you-go pricing with no charge while it is stopped.
• The model's side is pay-per-use as well: Bitdeer AI's Model Studio is a service you call over the internet and pay for by the token, so a check that runs once a day pays for that day's text, not for chips sitting idle.
• A scheduled job in Bitdeer's guide is an ordinary chore: read the inbox, pull out the action items and send a daily digest at a set time.

In more detail

• Bitdeer's example: a basic cloud computer with 2 cores and 4 GB of memory is enough to run an agent, at about $0.0363 an hour, because running the agent does not need graphics chips.
• The model is billed separately, per million tokens. Those are two different units, an hour of computer time and a count of tokens, so the two numbers cannot be compared directly.
• Bitdeer's guidance keeps the two apart: ordinary computers can handle scheduling, the front doors that route requests (gateways), databases and the agent's runtime, keeping the graphics chips focused on the model's own work.

In more detail

• One request from you can mean many calls: agent work may trigger several model calls, lookups and tool actions for a single request, so Bitdeer's planning guide says capacity cannot be worked out from one call.
• Bitdeer's own worked example: an agent making 60 tool calls in a row adds only a few hundred tokens of new text at each step, while carrying tens of thousands of tokens of history into every one.
• Text the model has already read can be kept on hand for reuse, and Bitdeer AI's price list charges much less for it: one model lists $0.15 per million tokens of fresh input against $0.003 for cached input.
• One way to cut the cost: a smaller model for easy steps and a bigger one for hard steps. Bitdeer's write-up on always-on agents puts it as sending each step to the right model, since many steps are high-volume and repetitive.
• Cost is described as the most significant constraint: token use grows with usage, so an expense that looks manageable in a trial can become unsustainable at scale.

In more detail

• Helpers suit jobs that split into independent pieces: in the agent-to-agent standard Bitdeer describes, agents can finish subtasks independently and at the same time, like five restaurants checked at once.
• A helper can start helpers of its own: in Bitdeer's trip-planning example, the flight agent asks a currency agent to work out exchange rates, and agents can be created on demand.
• The split-and-merge idea works inside a single model too: a research model that Bitdeer AI supplied chips for splits a hard question into parts, works each part on its own path, then merges the paths into one answer.
• What a helper sends back is a structured answer, filled in like a form rather than written as a loose message, in a format built so that each step can be traced.

In more detail

• Unlike helpers (part 4i), specialists each have their own expertise or role, as in Bitdeer's example of a marketing agent team.
• A team can include a checker. In Bitdeer's product-launch example, one agent runs quality checks on the others' work for factual accuracy, tone and brand alignment, the way one agent here could check that the booking says Friday and stays under $150.
• The number of pairings is every two agents that could talk to each other: 1 for two agents, 3 for three, 6 for four, 10 for five. It counts places a mix-up could happen, not how likely one is.
• In the agent-to-agent style, each agent acts on its own and can start subtasks of its own, so one request can fan out into several pieces of work.
• A team can also send each step to whichever model suits it best: a large model for coordinating the work and hard reasoning, and smaller specialised models for high-volume, repetitive work.

In more detail

• Companies that run models for others add graphics chips as demand rises and release them when traffic drops, which is how a rush stays affordable. That is the business Bitdeer AI Cloud is in.
• A rush hits three things at once: the model, the search databases behind lookups and outside services such as the booking system. If the system behind an agent cannot adapt in real time, the result is slow responses or even outages.
• Bitdeer's guidance for a service that must always be up is to set ahead of time a minimum number of copies running, some warm spare capacity, the level at which to add more, a limit on the waiting line and a fallback for when that is still not enough.
• Electricity is the slow part. How fast a data centre can secure and switch on stable power often decides how fast it can add capacity, and building new supply can take years while demand for AI grows quarter by quarter.

In more detail

• Bitdeer's blog draws the ladder in four stages. An assistant answers only when asked. A workflow starts when an event happens, such as an invoice arriving. An agent is given a goal and finds its own steps. A multi-agent system is several specialists working together.
• A flawed summary costs minutes to fix. An agent that cancels a booking without authorization creates a business incident with financial, legal and reputational cost.
• Bitdeer's blog asks five questions first: is its reasoning reliable enough for this task; what data will it touch, and does it need all of it; which systems can it reach; which decisions need a person first; and could you rebuild what happened afterwards?
• The rung can differ by task: booking alone for a regular Friday table, waiting for your tap for anything with a deposit.
• Bitdeer's blog calls this leverage with less certainty: more freedom gets more done, and carries more risk, together. Its advice is to manage an agent like a team member, saying what it can and cannot do, setting clear boundaries and watching how it performs.

In more detail

• A spending ceiling that switches the whole job off is a different thing from a cap on how many tries one step gets (part 3c).
• Bitdeer's guardrails article names isolation and rate limits for high-risk tool calls in particular, so the booking tool can be held to one table an evening while harmless lookups run freely.
• It also names a supervisor: agents that watch a running agent and can override its behaviour.
• Bitdeer's own model service works this way. By default it allows 100 requests a minute and answers anything above that with a retry-later message, and it has a separate limit on how much text can be used.
• A repeating glitch also costs real money, because the model is paid for by the amount of text. Bitdeer's blog notes that what begins as a manageable expense in testing can become unsustainable at scale.

In more detail

• Whether an answer invents a plausible policy or quotes the real one is not decided by which model you use. Bitdeer's blog calls it a data architecture decision, and describes the fix as fetching the relevant documents at the moment of the question rather than relying on what the model learned in training.
• A system can be told to say “I'm not sure” rather than guess when the evidence is thin.
• The lookup can be told to cite. Bitdeer's article puts the retrieved documents into the prompt with an explicit instruction to cite or synthesise them, so the answer can point back to the cancellation policy it read.
• Documents can carry labels such as date, author and type, and the search uses them to narrow the pile before it starts.
• Reading is only as good as what is read: if the source is biased, out of date or badly organised, the agent's answers suffer too. Bitdeer's blog adds that results may be influenced by the data sources, so businesses need regular audits to keep answers accurate and fair.

In more detail

• People already get this on a cloud. In Bitdeer's guide, finance can only view billing and developers can only operate servers inside the test area. An agent's book-only access is the same idea.
• The same questions apply to data and reach: what will it read, does it need all of it, and which systems can it reach?
• Access can be set by the agent's role or by the situation it is in, not one setting for everything.
• Bitdeer's Agent Builder sets strict boundaries for the data and outside services an agent can reach.

In more detail

• Engineers call this prompt injection. Bitdeer's guardrails article lists defences that stack: check what comes in for tricks and unclear intent, send each request down a path that fits its risk, and build walls behind that.
• A wall works because of where it sits. OpenShell, the runtime Bitdeer's blog describes, enforces its rules in the program that runs the agent instead of relying only on prompts or guardrails inside the agent.
• OpenShell has four walls: two fixed when the agent is created (its files and its processes) and two adjustable while it runs (its network and where its model requests go).
• A privacy router decides where each request to a model goes, which helps keep sensitive context such as calendar details under tighter control.
• Bitdeer's setup guide runs the agent in a sandbox, a sealed-off area, and lets you write your own network rules for what the agent may reach.

In more detail

• Two plain ways to watch an agent over time: a log of what it did, and notes kept as ordinary text files a person can open.
• Bitdeer's blog ties drift to long tasks, where agents keep exchanging conversation history, tool results and intermediate steps turn after turn. That is also what makes long agent work cost more.
• Watching does not stop at launch. Bitdeer's guardrails article says the controls must carry on into production, so someone can step in, see what happened and be held to account.
• Memory design matters as much as the model. In Bitdeer's account of teams running AI in production, context management, memory design and workflow integration become as important as the model itself.

In more detail

• The six layers come from Bitdeer's guardrails article: input, model, output, tool access, monitoring and governance.
• Only the first four stop something directly. Monitoring and governance watch and set the rules, so they are drawn as a log and a rulebook, not as gates.
• Each layer has its own techniques. The input layer uses prompt templates to keep requests in a set shape, and the output layer scans replies for harmful, biased or personal content.
• The last layer is written policy: rules for how the agent may be used, a safety check during development, testing and rollout, and a plan for what to do when something fails.
• Bitdeer builds guardrails in from the outset instead of after an incident. Its Agent Builder combines model-level safeguards with platform controls: strict access limits, a record of every interaction, and scanning of inputs and outputs.