Software that grows with intelligence.
Artificial Beings is a natural-language application compiler and model-agnostic runtime. It turns descriptions into stateful applications with their own code, tools, interfaces, memory, and identity. Those applications can act, collaborate, and improve while the underlying intelligence remains replaceable. When analyzing AB, one should first envision a future where intelligence grows exponentially, then its true merits will reveal itself.
The model is a component. The application is the enduring asset.
1. Describe the software. AB builds it.
- Turn ordinary language into a reviewable application design covering purpose, behavior, records, tools, rules, and interfaces.
- Generate complete agent applications: backend code, typed tools, structured records, custom React dashboards, and tests.
- Work with specialist builders to refine functionality and interfaces, with browser-based inspection, design comparisons, and retained project histories.
2. Keep the memory. Upgrade the intelligence.
- Preserve agent identity, conversation history, structured memory, and operational records independently of the selected model.
- Switch reasoning providers without abandoning saved work, and preserve continuity through compatible application revisions.
- Give each agent its own purpose, personality, language, editable rules, and behavior informed by its current state.
3. Build software that can keep improving.
- Run goal-directed Evolve attempts against installed agents, retaining candidate implementations and evaluation state.
- Develop changes separately from live applications, validate exact revisions, obtain independent review, and promote the selected candidate.
- Turn committed specifications into training data for domain-specific adapters, with evaluation, canary deployment, promotion, hold, and reversion controls.
4. Turn conversations into durable work.
- Equip agents with custom Python tools, authenticated service connections, structured data ingestion, and typed inputs and outputs.
- Execute multi-step jobs beyond a single chat turn, with progress tracking, pause, resume, cancellation, and restart recovery.
- Retain execution receipts, reuse completed results on matching retries, and hold uncertain external effects for reconciliation instead of blindly repeating them.
5. Build networks of collaborating agents.
- Let agents discover and call teammates across worlds, processes, and authorized organization partnerships.
- Share selected work states with separate read and write permissions, scoped caller identities, and recorded agent-to-agent interactions.
- Coordinate managed peers through authorized tasks and constrained artifact exchange, extending collaboration across execution environments.
6. Give intelligence real tools—and explicit authority.
- Run generated applications in isolated sandboxes, with scoped tool access, permissions, network boundaries, and host-enforced execution controls.
- Protect credentials through dedicated secret-entry flows, encrypted secret storage, mediated service access, and tool-output scrubbing.
- Bring people into the workflow through structured requests, review cards, and enforceable approval, execution, and rejection decisions.
7. Build the interface around the work.
- Combine conversation with live dashboards, forms, buttons, structured cards, and interactive widgets connected to application state.
- Work across text, structured data, images, audio, PDFs, spreadsheets, and model-produced media.
- Reach people through web, mobile, and Telegram—or create custom experiences using reusable interface components, TypeScript clients, and headless APIs.
8. Run across models, machines, and environments.
- Use an architecture designed for hosted, local, and edge deployment, built on raw network transports and replaceable provider integrations.
- Combine cloud providers, OpenAI-compatible servers, local MLX inference, vLLM, and custom model plugins, with per-agent configurations, fallbacks, and confidence-based escalation.
- Connect external software through SDKs, MCP-style tool and state interfaces, and coding-agent loops such as Codex, Claude Code, and LangGraph.
9. Turn individual agents into organizational infrastructure.
- Create organization addresses and named worlds, with invitations, scoped membership, roles, and shared workspaces.
- Distribute public, signed-in-customer, and private agent experiences, including separate personal copies and privacy-preserving organization identities.
- Publish validated applications tied to exact revisions and launch identities, supported by account controls and organization, membership, plan, and billing synchronization.
10. Extend agents into games and simulated worlds.
- Give Unity characters persistent agent identities, simulated sight and hearing, and actions connected to developer-written game behavior.
- Build modeled environments with object interactions, action receipts, 3D dashboards, and animated avatars.
- Explore embodied learning through Minecraft motor goals, collected training transitions, and predictive visual rollouts from a GPU sidecar.
The bigger possibility
AB begins with creating an application from a description. Its larger opportunity is to let people create entire collaborating systems of intelligent software: applications that retain knowledge, coordinate work, develop specialized capabilities, and benefit from successive generations of AI.
In a future of rapidly advancing intelligence, the application should not become obsolete every time the model improves. It should become a more valuable place to apply that intelligence.