Felidae is Xnovity's research direction for programming AI agents as auditable software.
Felidae explores a language and runtime model where agents, memory, tool calls, policies, human approvals, and structured outputs are explicit program concepts. It is for engineers designing secure AI applications who want more than prompt strings stitched into Python or framework code.
agent ResearchAssistant {
intent "answer with cited context"
memory scoped user
tools {
search_docs(query: Text) -> List<Citation>
}
policy {
require citation for every external_claim
require human_approval before publishing
}
}Modern AI development is fragmented across prompts, tools, memory, policies, and workflow glue.
Python and AI frameworks are powerful, and they remain the practical default today. Felidae asks a narrower language-design question: what if the parts that make AI systems risky or hard to review became explicit compiler and runtime concerns?
Prompt engineering
Treat prompts as typed, reviewable program artifacts instead of hidden strings scattered through product code.
Tool calling
Represent tool permissions, schemas, retries, and audit expectations as language or runtime concepts.
Memory
Make short-term, long-term, user-scoped, and policy-scoped memory explicit enough to reason about before runtime.
Policies
Move safety, data-boundary, approval, and logging rules closer to the code that invokes models and tools.
Agent orchestration
Describe agent roles, handoffs, approvals, failure paths, and explanations without burying them in framework glue.
RAG and workflow management
Expose retrieval, citations, workflow state, and structured outputs as first-class design targets.
Architecture-oriented use cases, with maturity made visible.
These are design targets for an AI-native language and runtime. Regulated or safety-sensitive domains are framed conservatively because this repo does not prove production readiness.
Coding agents
ResearchProblem: Agentic development stacks mix prompts, tools, permissions, memory, and approvals across several libraries.
Felidae approach: Felidae explores a language-level way to describe agent capabilities, tool boundaries, and human approval checkpoints.
Benefit: Clearer reviews, safer automation design, and stronger audit trails when the runtime exists.
Customer support
ResearchProblem: Support copilots need policy-aware responses, escalation, RAG citations, and controlled actions.
Felidae approach: Felidae can model support agents, knowledge retrieval, response structure, and escalation policies as explicit program elements.
Benefit: Lower ambiguity around what the agent may answer, retrieve, or change.
Finance
ResearchProblem: Finance automation requires approvals, traceability, and strict separation between advice and action.
Felidae approach: Felidae's policy direction emphasizes typed tool calls, human approval, and audit requirements before execution.
Benefit: Useful for designing safer workflows; not a regulated-finance product claim.
Robotics
ResearchProblem: Robotic systems must coordinate perception, planning, actions, safety limits, and operator intervention.
Felidae approach: Felidae can be studied as an orchestration language for declaring permissions and recovery paths around tools.
Benefit: A potential specification layer for explainable actions, not a robotics runtime today.
Healthcare
ResearchProblem: Healthcare workflows need privacy, citations, review, and conservative automation boundaries.
Felidae approach: Felidae's planned policy primitives could make data access and human review requirements explicit.
Benefit: Helpful as a research direction; no clinical, diagnostic, HIPAA, or regulatory readiness is claimed.
Enterprise automation
ResearchProblem: Enterprise AI workflows span tickets, documents, approvals, APIs, and identity boundaries.
Felidae approach: Felidae aims to describe agents, tools, policies, and workflow state in one auditable program model.
Benefit: A clearer design surface for automation governance when implementation matures.
Scientific research
ResearchProblem: Research assistants need reproducible context, structured outputs, tool provenance, and review loops.
Felidae approach: Felidae can explore syntax for experiments, retrieval, reasoning steps, and evidence capture.
Benefit: Potentially better reproducibility and reviewability; no benchmarked research platform exists yet.
Education
ResearchProblem: AI tutors must explain reasoning, respect policies, and avoid unreviewed high-stakes claims.
Felidae approach: Felidae can model tutor roles, content scope, guardrails, and handoff conditions.
Benefit: A promising language-design use case for transparent AI behavior.
Consistent design sketches, not claimed compiler input.
The repository does not include a parser, grammar, or language tests. These examples are deliberately labeled as research syntax so they do not conflict with an implementation.
- Covers agents, memory, tools, policies, outputs, workflows, recovery, reasoning, approvals, and permissions.
- Uses one readable proposed style instead of pretending an unsupported grammar exists.
- Each snippet has an accessible copy button.
Agent definition
A proposed shape for declaring an agent, its intent, and the tools it may request.
Design sketch only. No parser or compiler in this checkout currently supports this syntax.
agent SupportNavigator {
intent "answer account questions with cited context"
tools {
read_ticket(id: TicketId) -> Ticket
search_docs(query: Text) -> List<Citation>
}
output SupportAnswer {
summary: Text
citations: List<Citation>
escalation_required: Bool
}
}Lexer - Parser - AST - Semantic Analysis - Policy Validation - Optimizer - IR - Code Generation - Runtime
The pipeline below is the intended architecture. No stage is marked completed because this checkout does not contain Felidae compiler source.
Lexer
Tokenize source text. No lexer source is present in this checkout.
Parser
Build a parse tree from grammar rules. No parser source is present in this checkout.
AST
Normalize parsed syntax into compiler data structures.
Semantic Analysis
Resolve names, types, scopes, effects, tools, and policy references.
Policy Validation
Check data, tool, approval, and audit boundaries before execution.
Optimizer
Plan model/tool calls for reliability, latency, and cost.
IR
Intermediate representation for agents, policies, memory, and workflow execution.
Code Generation
Potential backend generation is not implemented in this repo.
Runtime
Runtime for agents, tools, memory, and policies remains a research direction.
Design principle
Make AI behavior reviewable as code: agents, tools, memory, policy, approvals, outputs, and traces should be explicit.
Evidence boundary
This website is the only Felidae source present in the checkout. Compiler/runtime claims are therefore labeled planned or research.
Interoperability posture
Felidae should complement Python and AI frameworks first, not claim replacement status before implementation proves it.
Languages and frameworks solve different layers of the AI stack.
Felidae should not be read as feature parity with mature languages or agent frameworks. It is earlier, and its positioning is about language-level expression for AI behavior.
| Tool | Layer | Native agents | Compiler | Memory | Policies | Security | Tool calling | Type safety | Structured outputs | Observability | Explainability | Concurrency |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Python Python is the better choice today for practical AI implementation. | General-purpose language and AI ecosystem | Library/framework level | Interpreter and multiple implementations | Application/framework managed | Application/framework managed | Mature ecosystem patterns | Framework/API level | Optional gradual typing | Library/API validation | Mature third-party tooling | Framework-specific | Threads, async, processes |
| Rust Felidae is not evidenced as a systems-language competitor. | Systems programming language | Not a native concept | Production-grade native compiler | Ownership and borrowing | Application/library level | Strong memory-safety model | Library/API level | Strong static typing | Type and crate ecosystem | Crate/tooling ecosystem | Application-specific | Fearless-concurrency model |
| TypeScript TypeScript remains stronger for shipped web products today. | Typed JavaScript application language | Framework/API level | Type checker and JS emit | JavaScript runtime managed | Application/framework managed | Web and Node ecosystem patterns | Framework/API level | Static types erased at runtime | Schema libraries and SDKs | Mature web/server tooling | Application-specific | Event loop, workers, async |
| LangChain Frameworks solve orchestration today; Felidae explores language-level expression. | AI application framework | Framework primitive | No language compiler | Framework integrations | Application/framework patterns | Application responsibility | Framework primitive | Host-language dependent | Parser/schema integrations | Ecosystem integrations | Tracing/tooling dependent | Host-language dependent |
| Semantic Kernel A practical SDK layer rather than a programming language. | AI orchestration SDK | SDK concept | No language compiler | Connector/plugin model | Application/SDK configuration | Host and deployment dependent | Plugin/function model | Host-language dependent | SDK and schema dependent | Application/infrastructure dependent | Application-specific | Host-language dependent |
| CrewAI Useful for agent workflows now; Felidae is earlier and lower-level in ambition. | Agent orchestration framework | Framework primitive | No language compiler | Framework/application managed | Application configured | Application responsibility | Framework primitive | Host-language dependent | Framework/schema dependent | Framework/tooling dependent | Task/agent traces | Host-language dependent |
Python's strengths
Python has the best practical AI ecosystem today: model APIs, data tools, notebooks, orchestration libraries, evaluation tooling, and hiring depth.
Felidae's intended strengths
Felidae aims to make agent roles, tool permissions, memory scope, policies, approvals, and structured outputs visible as language/runtime concerns.
When Python is better
Use Python today for production AI systems, experiments, data science, integrations, and any project that needs mature libraries immediately.
When Felidae may fit
Felidae may become appropriate when implementation proves language-level agent governance, policy validation, and runtime traces are useful enough to adopt.
Transparent maturity matrix from repository evidence.
States are limited to Completed, In Progress, Planned, and Research. Items are intentionally conservative because source code evidence is missing for the language implementation.
| Area | State | Evidence | Reference |
|---|---|---|---|
| Parser | Planned | No parser, grammar, or parser tests found in this checkout. | View |
| Compiler | Research | Compiler pipeline exists as website roadmap and documentation direction only. | View |
| Runtime | Research | No Felidae runtime source found; runtime concepts are research topics. | View |
| CLI | Planned | No Felidae CLI package or command found. | View |
| LSP | Planned | No language server source found. | View |
| VS Code extension | Planned | No VS Code extension manifest found. | View |
| IntelliJ IDEA extension | Planned | No JetBrains plugin source found. | View |
| Playground | Planned | No playground route or compiler-backed execution service found. | View |
| Documentation | In Progress | This website now exposes crawlable Felidae documentation pages. | View |
| Open source | Planned | No public repository, license file, or issue tracker found in this checkout. | View |
Crawlable developer resources, with planned pages clearly labeled.
Search and open the current Felidae resource map. Existing evidence is reused; missing resources are marked planned instead of fabricated.
Will become the first practical developer path after a compiler or playground is available.
No installer exists in this checkout.
Deferred until supported syntax exists.
Current page separates research topics from supported syntax.
Documents known gaps and planned syntax areas honestly.
Pipeline responsibilities and missing source paths.
Runtime responsibilities and open questions.
No package system is present.
No standard library is present.
No command-line tool is present.
Design sketches are labeled non-executable.
Tutorials should wait for supported syntax.
Reference material is not yet backed by implementation.
Expanded website FAQ for developer and enterprise questions.
No tags or releases were found.
No Felidae changelog exists yet.
The site has a blog; Felidae-specific updates should be published there when real updates exist.
Central links now exist, with planned items clearly marked.
No ADRs found for Felidae.
No Felidae RFCs found.
Only methodology is published; no measurements are claimed.
Status matrix and transparent next milestones.
What serious builders can inspect next.
Technical questions answered from repository evidence.
Why another language?
Felidae explores whether agents, memory, tools, policies, approvals, and structured outputs should be expressed as language/runtime concepts instead of scattered framework code. The current repo does not prove a completed language implementation.
Is Felidae a general-purpose language?
Not today. The evidence supports presenting Felidae as an AI-native programming-language direction, not a general-purpose replacement for Python, TypeScript, Go, Rust, Kotlin, Swift, or Java.
Is it a logic-programming language?
Felidae is successor-inspired by logic-programming ideas, especially explicit relations and reasoning, but no implemented fact, rule, or relation syntax is present in this checkout.
Does it use LLVM?
No LLVM backend is present in this repository. Any LLVM target should be treated as planned or research until source code proves it.
Does it target WASM?
No WASM target is present in this repository.
Does it target the JVM?
No JVM backend is present in this repository. Older static copy mentioned Java-based compilation, but the current repo does not prove it.
Does it interoperate with Python?
No Python interoperability layer is present. Python remains the better practical choice for most AI work today.
Does it interoperate with Java?
No Java interoperability layer is present in this checkout.
What is the memory model?
The memory model is a research topic. The website discusses scoped memory as a design goal, not an implemented runtime guarantee.
Does it use garbage collection?
No runtime or memory-management implementation is present, so garbage collection is not specified.
Does it use ownership?
No ownership model is specified or implemented in this checkout.
Is it statically typed?
Typed tool contracts and structured outputs are design goals. A static type checker is not present in the repo.
How does concurrency work?
Concurrency is open research. Multi-agent workflow examples are design sketches rather than implemented scheduling semantics.
Is it open source?
No public repository or license file for Felidae was found in this checkout. Open-source plans should be considered planned until published.
What is the license?
No Felidae license file was found. The website should not imply a license until one is published.
Does it support MCP?
No MCP support is present in this checkout.
What is the agent runtime?
The agent runtime is a research direction for executing tools, policies, memory, approvals, and traces. No runtime source is present.
How are policies enforced?
Policy enforcement is not implemented here. The intended direction is compile-time and runtime validation of permissions, approvals, citations, and audit requirements.
How are tools permissioned?
Tool permissioning is currently a design goal. Examples show desired boundaries, not working syntax.
What is currently production-ready?
The website and documentation pages are production-rendered. The Felidae language, compiler, runtime, CLI, LSP, playground, and package ecosystem are not proven production-ready by this repository.
How can developers contribute?
A contribution guide, public repository, issue tracker, and RFC process are planned resources. Until those exist, the best action is to follow Xnovity updates or contact the team.
Interested in Felidae research or AI-native language design?
Contact Xnovity for research collaboration, early feedback, or enterprise AI architecture discussions. No Discord, newsletter, GitHub repository, or issue tracker link is shown because none was found in this checkout.