Artificial Beings
How it worksDevelopers

Build AI applications that grow with intelligence.

Artificial Beings (AB) is a natural-language application compiler and model-agnostic execution runtime, not a turnkey cloud automation or chatbot wrapper. The system translates plain-English descriptions into deterministic, stateful software applications by automatically compiling source code, typed tool schemas, and custom dashboards inside isolated sandboxes. Critically, the platform strictly decouples an agent’s persistent database state and structured memory from the underlying AI model. This ensures total data sovereignty and historical continuity even when hotswapping volatile LLM reasoning providers. It operates via raw network transports, prioritizing long-term architectural stability and edge deployment over immediate retail convenience. When analyzing AB, one should first envision a future where intelligence grows exponentially, then its true merits will uncover.

Create and change agents

  • Create an agent by describing what you need in ordinary language.
  • Turn an idea into a readable design covering the agent’s work, records, tools, rules and views.
  • Review the design before asking Maker to build.
  • Ask for design changes in the same conversation.
  • See what changed against an earlier accepted or built design.
  • Generate an agent application with its own identity, backend and frontend.
  • Create custom tools for work that goes beyond standard record operations.
  • Generate tests alongside custom tool implementations.
  • Ask specialist builders to work on tools, interfaces and application behavior.
  • Revise an installed agent through a retained candidate rather than changing the live application immediately.
  • Keep the same agent identity and saved work through compatible revisions.
  • Keep separate Maker conversations, designs and build histories for different projects.
  • Name and archive Maker sessions.
  • Build in an organization and world the person is allowed to edit.

Build an interface around the work

  • Give an agent a dashboard alongside its conversation.
  • Build custom React interfaces for a particular workflow.
  • Add forms, buttons and controls that connect to agent actions or state.
  • Update interface data as agent state changes.
  • Show structured cards and interactive widgets inside chat.
  • Connect a conversation to selected records or the current work view when the application implements that context.
  • Have a Frontend specialist inspect a candidate interface in a real browser.
  • Preview an installed agent’s data without allowing preview changes to modify it.

Keep memory and structured work

  • Keep completed conversation history for later turns.
  • Store agent work outside the selected model.
  • Maintain structured records across sessions with a configured persistent store.
  • Give records stable identities so tools and views refer to the same objects.
  • Manage multiple lists of typed records.
  • Calculate totals, ranges and formulas in code.
  • Keep voided records instead of silently losing their history in supported generated applications.
  • Store named state values that tools and interfaces can use.
  • Update a state through read-transform-write helpers scoped to that key.
  • Share selected nonsecret states with named readers or writers.
  • Revoke copy-level sharing grants.
  • Retain saved records through supported model changes when the same agent identity and store are retained.
  • Import structured CSV or JSON source rows through configured ingestion tools.

Give agents tools and real connections

  • Register custom Python tools for particular agent types.
  • Run developer-owned tool bodies in the connected client process.
  • Use synchronous or asynchronous tool implementations.
  • Describe tool arguments through typed schemas.
  • Restrict which agents can see or call a tool.
  • Observe tool execution through events and recorded outcomes.
  • Build authenticated HTTPS tools for fixed, allowed destinations.
  • Build TLS email submission tools for configured hosts and recipients.
  • Supply credentials through a dedicated secret-entry flow.
  • Apply destination, recipient and network checks to supported service helpers.
  • Expose registered tools through supported MCP-style methods.
  • Expose permitted nonsecret agent states as readable resources.
  • Use external coding-agent loops such as supported Codex, Claude Code or LangGraph configurations.

Involve people and enforce authored controls

  • Present designs and revisions for a person to review.
  • Ask a person to fill typed fields through a structured request card.
  • Request credentials through secret fields rather than an ordinary chat message.
  • Validate requested fields before saving them.
  • Expire input requests and close them after completion.
  • Keep secret values out of ordinary state-read responses.
  • Encrypt supported secret states using host-managed encryption.
  • Scrub secret values read by supported tool code from its outputs, errors and receipts.
  • Define roles and permissions around custom tools and shared work.
  • Add review, execute or reject cards to workflows whose action handlers enforce those choices.
  • Refuse confirmation-marked tools on public tool-call paths that lack the required private authority.
  • Route supported rule, model, job, interface change requests from an agent’s own chat to host controls.

Continue work beyond a single chat turn

  • Start finite, multi-step tool jobs from a message.
  • Let a configured job continue while its screen is closed.
  • Keep a record of each job step and result.
  • Show job progress and completion state.
  • Pause a job before its next step.
  • Resume a paused job.
  • Stop a job while retaining completed work.
  • Recover completed steps from persisted receipts after supported restarts.
  • Hold uncertain effects instead of blindly repeating them.
  • Submit background runtime tasks and retrieve their status.
  • Reconnect to streamed progress and recover completed answers.
  • Request cooperative task cancellation.

Let agents work together

  • Define teammates in an agent design.
  • Discover callable agents in a configured world.
  • Ask another permitted agent a question.
  • Collaborate with agents running in other processes through the gateway.
  • Make configured partner calls across organization boundaries.
  • Carry a scoped caller identity into an agent-to-agent call.
  • Keep receipts of agent calls.
  • Share selected work states between agents.
  • Grant read and write access separately where supported.
  • Constrain calls through target callability, permissions and cycle checks.

Choose and combine models

  • Configure agents with supported OpenAI, OpenRouter, Anthropic or Gemini provider paths.
  • Connect supported OpenAI-compatible model servers such as vLLM.
  • Author custom provider plugins.
  • Give different agents different model configurations.
  • Switch a generated agent between its supported managed runtime choices.
  • See the difference between a saved model selection and the observed running configuration.
  • Try a configured fallback provider when an earlier provider call fails.
  • Escalate a calibrated structured decision to another configured model when confidence is low.
  • Record which provider and model served a result.
  • Request named, schema-constrained answers from compatible providers.
  • Run supported local text models through the embedded MLX path.
  • Attach to or manage a compatible vLLM server.
  • Resume supported external coding-loop sessions.
  • Steer a supported live terminal loop through the developer API.

Work with files and media

  • Send text and structured JSON into agent turns.
  • Accept PNG or JPEG images for compatible, configured vision agents.
  • Carry audio input to compatible, configured models.
  • Pass PDFs to supporting models through the file-input path.
  • Decode supported spreadsheets into model-facing cell text.
  • Read supported text and JSON attachments.
  • Return structured data parts rather than prose alone.
  • Carry provider-produced image or audio outputs through supported replies.
  • Render supported image, audio and file outputs in the client.
  • Record audio in compatible client surfaces for dispatch to the agent.
  • Export structured work as CSV in applications that implement it.

Give each agent a purpose and style

  • Give an agent a defined purpose and role.
  • Author its personality and instructions.
  • Set an authored display language and behavior guidance.
  • Derive per-turn behavior from the agent’s current state.
  • Declare editable rules with allowed types and values.
  • Re-read supported rule changes into later turns.
  • Keep an agent’s identity distinct from its underlying model configuration.

Run agents for people and organizations

  • Give an organization its own address.
  • Reserve an organization address through a gated self-serve flow.
  • Create multiple named worlds for different areas of work.
  • Keep worlds private or configure public and signed-in-customer visibility on eligible plans.
  • Invite people to an organization.
  • Assign editor or user roles.
  • Restrict members to selected worlds.
  • Withdraw invitations and remove member access.
  • Reactivate an existing membership when someone is invited back.
  • List the organizations and agents a person can open.
  • Give signed-in people separate private copies on supported agents.
  • Keep anonymous shared copies separate from signed-in private copies.
  • Hand an account session to an organization using a masked, organization-specific identity.
  • Keep raw account email and account UUID out of that host handoff.

See what happened and recover carefully

  • Inspect tool activity and outcomes.
  • Follow model-provider attempts and available usage receipts.
  • Read task, thread and conversation history.
  • Inspect build stages and validation evidence.
  • Distinguish building, waiting, partial, failed and completed build states.
  • Retain rejected or interrupted candidate work for review and supported continuation.
  • Stop and resume supported build attempts.
  • Validate an exact candidate revision before promotion.
  • Obtain independent review of the candidate being promoted.
  • Check the launched revision before publishing its hosted interface.
  • Keep effect records for supported loop-tool calls.
  • Reuse completed results for matching idempotent retries.
  • Fence indeterminate effects for reconciliation.
  • Record metadata about outside writes to shared states.
  • Inspect registered model plugins and perform privileged hot reload after draining calls.

Host and protect the application

  • Publish validated dashboard agents under an organization and world.
  • Keep published status tied to an exact revision and launch identity.
  • Show readiness or publication failures instead of treating frontend files alone as a working deployment.
  • Mediate provider credentials and supported network requests at an egress boundary.
  • Protect engine access through service authentication and supported browser tickets.
  • Guard account-changing requests against cross-origin submissions.
  • Apply account database row and column access controls.
  • Synchronize organization, world, plan and membership changes through a scoped infrastructure feed.
  • Deduplicate verified billing events and retain failed events for reconciliation.

Connect through SDKs, phones and games

  • Build a custom web application around the TypeScript client API.
  • Send messages, call tools, access states and receive live events from a headless client.
  • Use reusable dashboard widgets, forms and controls in a custom interface.
  • Connect Unity NPCs to model-backed AB agents.
  • Give Unity agents persona and game-state observations.
  • Route declared agent actions to developer-written game handlers.
  • Keep game-agent state and conversation history through the bridge store.
  • Sign in to a hosted organization, browse agents, chat and open dashboards from the mobile app.
  • Review Maker designs and build state on the phone.
  • Relay Telegram text and dashboard/widget links through the separate reusable bot package.
  • Render an optional VRM avatar with gaze, blinking and expression blending.
  • Map supplied agent state to an RP1 avatar’s pose and position.

Simulated worlds and embodied demonstrations

  • Generate an agent that observes and acts in a modeled world.
  • Perform supported move, pick and place-style actions on named objects.
  • Show the same world state in a 3D dashboard with a list fallback.
  • Keep action receipts and enforce supported object/action constraints.
  • Give Unity NPCs simulated sight from game positions and colliders.
  • Give Unity NPCs simulated hearing from in-game speech broadcasts.
  • Run repeated observation, reasoning and action turns in a configured Unity game.
  • Demonstrate exact proposed-action approval and receipt behavior against a host-owned stand-in destination.

Others

  • Run goal-directed Evolve improvement attempts against installed agents.
  • Amend, stop and resume supported Evolve attempts with retained candidate and evaluation state.
  • Route concurrent live messages to a current task and expose question or Allow/Deny waits.
  • Collect a committed-spec training corpus and train domain-specific adapters.
  • Evaluate, canary, promote, hold or revert supported trained artifacts.
  • Check gradient witnesses so a no-movement training run is not treated as healthy.
  • Execute Minecraft motor goals from live simulation observations and collect transitions for training.
  • Request predicted frame rollouts from a configured Cosmos GPU sidecar using a start frame and camera-pose actions.
  • Enroll managed peers, issue authorized tasks and exchange constrained artifact manifests.
  • Fence uncertain remote execution or spend claims before retrying.
  • Transcribe supported WAV audio and synthesize spoken replies through the optional local macOS adapter.