From intent
to action.
By design.

Turn human ideas and expert judgment into agentic systems. Compose local model roles, tools, reusable skills and project knowledge through a shared Rust platform.

Local task console and scoped Rust components implemented. Model inference, integrated RAG, native training and full-product acceptance remain separate.

Compose the loop.
Keep the contract.

Eyleme owns authority, execution and evidence. Architecture v0.7 connects optional model roles with typed tools, skills, source-grounded retrieval and purpose-scoped memory.

Implemented foundation

A growing local Rust core.

Task console, durable recovery, loop/model contracts, purpose-gated project data and bounded source context. Native tools, skill packages and decision evidence have scoped counter proofs; these are not general model or RAG execution.

Read the component evidence

Architecture v0.7 · integration in development

Compose a system for the job.

Nine optional model roles, reusable skills, RAG and project memory. Local inference, native Rust training and complete jobs need their own acceptance. External models require explicit configuration and disclosure permission; local-only has no hosted fallback.

Read the current architecture

Architecture v0.7 · integration design

Eyleme architecture v0.7: human goals and five separate data-use permissions govern jobs, nine optional model roles, tools and skills, Rust authority and observed feedback. Permitted sources supply RAG/recall context with six optional memory kinds and renewed rights, lineage and expiry checks. A separate planned loop moves permitted episodes through curation, native Rust LoRA/QLoRA training, held-out evaluation and human-controlled promotion back to model profiles and skills. Scoped implemented components are labeled separately; integrated retrieval and training still require acceptance.

Architecture v0.7 integration design. Nine optional roles use source-gated knowledge and memory; Rust retains execution authority. Native training and human-controlled promotion form a separate planned loop. Scoped implemented foundations do not establish integrated model, RAG or training acceptance.

Open full-size image (new tab)

Define a job, then compose its flow.

Declare goals, authority, budgets, typed tools and reusable skills. Choose only the roles the job needs; nine roles do not mean nine mandatory models. Start with local text and source-grounded reporting; audio, vision and world models are optional.

Read the loop contracts
Composable job design
Bounded job
  • Roles
  • Tools
  • Skills
  • Budgets

Architecture v0.7 · scoped components exist; integrated model jobs remain unaccepted

Accept profiles, not model names.

Match exact artifacts, operators, rights, schemas and hardware. Reasoning, planning, decision, action policy and retrieval remain distinct roles; speech input and output use separate profiles. Model manifests are implemented, but local inference remains explicitly unsupported until accepted.

Read the assignment lifecycle
Declared model assignments
Exact profile
  • Role
  • Artifact
  • Interface
  • Hardware

Architecture v0.7 · scoped components exist; integrated model jobs remain unaccepted

Ground context. Inspect actual effects.

Retrieve only currently permitted project sources. The implemented memory adapter resolves explicit references; vector search, graph traversal and analytical engines remain separate gates. Native decision evidence links submitted alternatives to actual bounded tool outcomes; a prediction or graph link is not a verified fact.

Read the authority contract
Source-grounded operating design
Permitted evidence
  • Recall
  • Propose
  • Validate
  • Observe

Architecture v0.7 · scoped components exist; integrated model jobs remain unaccepted

Improve without widening permissions.

Execution, collection, training, external disclosure and ecosystem export have separate rights. Derived data keeps source restrictions and lineage. Per-model native Rust gradients and LoRA/QLoRA are planned; external reference recipes do not prove owned-runtime training. Evaluate held-out tasks before controlled promotion.

Read the learning protocol
Planned improvement lifecycle
Permitted episodes
  • Curate
  • Train
  • Evaluate
  • Promote

Architecture v0.7 · scoped components exist; integrated model jobs remain unaccepted

Human direction, throughout.

Define authority. Inspect observed outcomes. Keep stop and revocation on the Rust control path.

A platform.
Clear boundaries.

What the current foundation does, what the architecture proposes and what still needs evidence.

What is Eyleme?

Eyleme is a Rust platform in development for composing bounded agentic jobs from model roles, tools, reusable skills and project knowledge. Humans define goals and authority; the platform records actual outcomes. Its implemented local task foundation is distinct from the broader model, RAG, memory and learning design.

Architecture v0.7
What works today?

The core includes the task console and scoped native loop/model contracts, project-data gates, explicit-reference memory context, typed counter tools, reusable counter skills and decision evidence. Each component has its own proof and limits. This promotional site does not run them, and those proofs do not establish general inference, graph search or complete harness jobs.

Implemented components and evidence
Has real human authorization been demonstrated?

Yes, in a bounded native macOS counter demonstration: an actual device-owner check, exact approval, effective stop before the remaining action, revocation and state-preserving reopen passed on 14 October 2026. This grants no data-training or sharing rights. The separate start --human/browser flow, remote identity and arbitrary model jobs were not part of that acceptance.

Native person acceptance and limits
Does every job need nine models?

No. The optional roles are perception, reasoning, planning, decision, action policy, world model, specialist, critic and representation/retrieval. One model may fill several compatible roles. Audio, vision and text profiles are distinct, and exact model acceptance is required before execution.

Roles and binding contracts
Can I run local models or connect an external one now?

Declared model artifact and role contracts are implemented; they do not load weights or run inference. Local assignments still report unsupported execution. The architecture permits explicitly configured external frontier models, but configuration is not authorization to disclose private data or make paid calls. A local-only profile never silently falls back to a hosted model.

Model contract and unsupported execution
How do RAG, memory and the knowledge graph fit?

The design grounds answers in permitted project documents and optional working, episodic, semantic, procedural, knowledge-graph and analytical memory. The current Rust adapter builds bounded context from explicit source references, rechecking rights, expiry and lineage. Semantic/vector retrieval, graph traversal, analytical engines and tokenizer counting remain separate acceptance gates.

Implemented source context and memory limits
How are decisions explained?

Native decision evidence joins submitted alternatives, constraints and declared model pins to actual scoped tool receipts and complete, partial or unknown outcomes. Confidence and model declarations remain unverified inputs. The current proof uses deterministic counter tools; model explanations, causal claims and whole-loop performance require separate evidence.

Decision evidence and measured scope
Can private project data train or enter the ecosystem?

Not automatically. Execute, collect, train, external disclosure and ecosystem export are independent purposes. Derived records inherit current source restrictions; withdrawal blocks future use but does not erase published copies or unlearn weights. Ecosystem packages need explicit selection, provenance, terms, review and compatible import acceptance.

Project-private purpose and lineage gates
How will local learning work?

The plan accepts training per exact model: owned Rust gradients, CPU/Metal LoRA and separately supported QLoRA, followed by independent evaluation and controlled promotion. Unsloth-like tooling remains a reviewed reference or recipe aid with separate export/reacceptance gates. No accepted native training or improved-model result is claimed.

Native improvement and acceptance
Which platform comes first?

The first experimental target is a single-user loopback application on a MacBook Pro with Apple M4 Pro and 24 GB unified memory. Browser and native execution have distinct boundaries. Mac mini M4 and Linux RTX equipment are additional inventory, not accepted support; remote access and Linux acceptance are future scope.

Accepted scope and hardware inventory
What is the project license?

Eyleme first-party core code and documentation use Apache-2.0. Separately identified third-party material, model weights and datasets retain their own terms. This does not grant a blanket license to every asset or model, or change the website repository license.

Core Apache-2.0 license

English is canonical. Turkish is a full companion.

Built in the open.
Proven step by step.

Build on the local foundation. Accept each model, knowledge flow and improvement step against its own evidence; component tests do not establish a complete agentic application.

  1. 01

    Owned Rust foundation

    Task console and scoped contracts, tools, skills, data gates, source context and native person proof.

    Scoped components implemented
  2. 02

    Accepted model jobs

    Exact domain profiles, owned CPU/Metal inference, typed tools and reusable local text flows.

    Execution acceptance pending
  3. 03

    Private knowledge and memory

    Source-grounded RAG, episodic and graph recall; analytics and backend profiles follow separately.

    Integrated acceptance pending
  4. 04

    Learning and reviewed delivery

    Native per-model training, independent evaluation, controlled promotion and real provider/GitHub delivery.

    Separate gates remain

Help shape what comes next.

Inspect the foundation. Review a contract. Contribute a bounded change with evidence.

Explore on GitHub